/* e2a - ENSDF to .ags conversion program */ #include #include #include #include #include #include "src/util.h" #include "src/gls.h" #define VERSION "e2a v0.0 (12 June 2000)" /* Common Block Declarations */ /* MLEV, MGAM, MBAND, MCARD : Maximum number of levels, gammas, bands, cards per data set */ #define MLEV 3000 #define MGAM 3000 #define MBAND 50 #define MCARD 4000 struct { double x[3], el[MLEV], del[MLEV], egam[MGAM], degam[MGAM]; float sp, dsp, sn, dsn; float igam[MGAM], digam[MGAM], d[MGAM], dd[MGAM], dd2[MGAM]; int a, z, iodd, theend, newds, nband, nlev, jlev, ngam, jgam; int spin[MLEV], bdstep[MBAND], bdk[MBAND], ioffs[MBAND]; int inlev[MGAM], finlev[MGAM], ml[MGAM][2]; char snucid[8], dsstr[40], nucid[8], dsid[80]; char mel[MLEV], ban[MLEV], parity[MLEV], unclev[MLEV], joffs[MLEV]; char jpimod[MLEV], levlab[MLEV][12]; char mlpar[MGAM], unctr[MGAM], mult[MGAM][12]; char bandid[MBAND][64], bd[MBAND], bdpi[MBAND], bdstr[MBAND][24]; char card[MCARD][120], *levcard[MLEV]; } gd; FILE *in_file, *logfile, *agsfile, *txtfile; int checkds(void); int read_ensdf(void); int escore(double e, double de, double x, double dx); int mjscor(char *mull, char *mj1, char *mj2); int spsn(char *str); int label(int ll, int iband, int n, char *name); int levstat(char unclev, int ispin, char parity, char jpimod, char joffs); int bdprop(void); int bandcheck(void); int wags(void); /* from str77 */ int iget(char *str); int getjpi(char *jpi, int *spin, char *parity, char *jpimod, char *joffs); int putjpi(char *jpi, int spin, char parity, char jpimod); int getml(char *mult, int *ml, char *parity); int jread(char *icard, int *j, char *pi, char *mjpi, int *l); int fend(char *ic1, char *mx, int len1, int len2); int zname(char *el, int *z, int iopt); int stopit(char *str1, char *str2, char *str3, int number); int chgam(double ein, double dein, double efi, double defi, double eg, double deg, int a, double elo, double delo, double ehi, double dehi); int chmult(int j1, char par1, char jpimod1, int j2, char par2, char jpimod2, int *ml, char *mlpar, char *mult, double eg, double el1, double el2, float d, float dd, float dd2, double elo, double delo, double ehi, double dehi); int match(double x, double *y, int i); extern int hsicc(int, float *, int, float *); #define NUMB(a) (a >= '0' && a <= '9') /* Hints and comments ****************** Radware AGS format Unknown spins in AGS format: spin=-1.0 or -0.5 for even/odd A Spin sequence J+x: Treated as band levels with unknown band head spin. If a value of J is given, it is used for a guess. *************************************************************** Revision log 06/12/2000/dcr (4.0) created by extracting relevant code from fconv.f 07/06/2000/dcr debugged to the point where it generates output essentially identical to the fortran version *************************************************************** Data set variables (in FORTRAN): SP, DSP Proton separation energy and Uncertainty SN, DSN Neutron separation energy and Uncertainty A Mass number of nucleus Z Charge of nucleus IODD 2 for odd nuclei, 1 for even nuclei NLev Number of levels EL, DEL Level energy and Uncertainty LevCard pointer to Level card for level i (for ENSDF input) Spin Spin of level. J=2 is spin=2 (IODD=1). J=5/2 is spin=5 (IODD=2). BdStep Delta J in band BdK Spin of band head ioffs Spin offset of band EGam, DEGam Gamma-ray energy and Uncertainty IGam, DIGam Gamma relative intensity and Uncertainty InLev Initial level of gamma (level number) FinLev Final level of gamma (level number) D, DD, DD2 Multipole mixing ratio and right & left uncertainty (+xx, -xx) ML Multipolarities of transition (L-values). ML=-1 is unknown TheEnd True when end of input file is reached NewDS True when new data set is found NBand Number of bands MEL Letter for +X in level energy Ban Band marker for level NucId Nucleus identification (A:1-3, element symbol:4-5) DSId Data set identification BD Band identifier Parity Parity of level (values '+','-',' ' is unknown parity) JPiMod Modifier to SPIN and PARITY: 'J' - spin uncertain, 'P' - parity uncertain, 'B' - both uncertain. MLPar Parity of transition ('+','-',' ' is unknown) UncLev Marker for uncertain levels JOffs Offset for spin (e.g. J) BdStr JPi field of band head LevLab Level label (for AGS format) BdPi Parity of band (for labelling) BandID Band identification string Mult Multipolarity of gamma (ENSDF string) SNucId Nucid for which nucleon separation energies are given DSStr String for selecting data sets UncTr Marker for uncertain transitions Card Card images of ENSDF data set (for ENSDF <-> ENSDF/2 conv.) ***********************************************************************/ int INDEX(char *a, char *b) { char *c; if (!(c = strstr(a,b))) return 0; return (int) (c - a + 1); } int main(void) { int num_per_nucl = 0, outsuffl, i, ii, prefixa, nc; char indir[80], inname[80], dum[8], dattim[20]; char last_nucl[16], outdir[80], outname[80], outsuff[16], fullname[256]; /* open log file */ if (!(logfile = fopen("e2a.log", "w"))) { printf("ERROR - cannot open log file!\n"); return 1; } datetime(dattim); fprintf(logfile, "%s\n", VERSION); fprintf(logfile, "ENSDF -> RadWare AGS conversion\n%s\n\n", dattim); printf("\n\n\n\n%s\n", VERSION); printf("ENSDF -> RadWare AGS conversion\n%s\n\n", dattim); /* get input and output directories */ nc = cask("Enter Input directory (rtn for current dir.) ?", indir, 70); if (nc && indir[nc-1] != '/') strcat(indir, "/"); nc = cask("Enter Output directory (rtn for current dir.) ?", outdir, 70); if (nc && outdir[nc-1] != '/') strcat(outdir, "/"); fprintf(logfile, "Input directory: %s\n", indir); fprintf(logfile, "Output directory: %s\n", outdir); /* get input data set selection string */ cask("Enter data set selection string (Case is significant,\n" " rtn for all data sets) ?", gd.dsstr, 40); if (*gd.dsstr) { fprintf(logfile, "Data set selection string: %s\n", gd.dsstr); printf("Data set selection string: %s\n", gd.dsstr); } OPENIN: /* get input filename and suffix for output filenames */ strncpy(last_nucl, "xxxxx", 5); if (!cask("Enter Input filename (rtn to quit) ?", inname, 70)) return 0; cask("Enter Suffix for output filenames ?", outsuff, 10); outsuffl = strlen(outsuff); prefixa = 0; if (*outdir && caskyn("Prefix A to output filenames? (Y/N)")) prefixa = 1; /* open input file */ strcpy(fullname, indir); strcat(fullname, inname); if (!(in_file = fopen(fullname, "r"))) { printf("ERROR - cannot open input file %s!\n", fullname); goto OPENIN; } gd.theend = 0; for (i = 0; i < 9000; ++i) { /* Read data */ read_ensdf(); if (gd.nlev >= 1 && (strncmp(outsuff, "misc", 4) || (!strstr(gd.dsid, "(HI,XNG)") && !strstr(gd.dsid, "(POL") && !strstr(gd.dsid, "(PI") && !strstr(gd.dsid, "(K") && !strstr(gd.dsid, "(MU") && !strstr(gd.dsid, "(G,") && !strstr(gd.dsid, "(N,") && !strstr(gd.dsid, "(P,") && !strstr(gd.dsid, "(D,") && !strstr(gd.dsid, "(T,")))) { if (strncmp(gd.nucid, last_nucl, 5)) num_per_nucl = 0; num_per_nucl++; strncpy(last_nucl, gd.nucid, 5); /* Write data */ /* first make up output file name */ for (ii = 0; ii < 5 ; ++ii) { if (gd.nucid[ii] == ' ') gd.nucid[ii] = '\0'; } if (!strncmp(outsuff, "misc", 4) || num_per_nucl > 1) { sprintf(outname, "%s_ensdf_%s%.2d.ags", gd.nucid, outsuff, num_per_nucl); } else if (outsuffl > 0) { sprintf(outname, "%s_ensdf_%s.ags", gd.nucid, outsuff); } else { sprintf(outname, "%s_ensdf.ags", gd.nucid); } if (outname[1] == ' ') outname[1] = '0'; if (outname[0] == ' ') outname[0] = '0'; strcpy(fullname, outdir); if (prefixa) { sprintf(dum, "%3.3d/", gd.a); strcat(fullname, dum); } strcat(fullname, outname); if (!(agsfile = fopen(fullname, "w"))) { printf("ERROR - cannot open output ags file %s!\n", fullname); return 1; } strcpy(strstr(fullname, ".ags"), ".txt"); if (!(txtfile = fopen(fullname, "w"))) { printf("ERROR - cannot open output txt file %s!\n", fullname); return 1; } fprintf(logfile, " input file: %s\n -> output file: %s\n", inname, outname); printf(" input file: %s\n -> output file: %s\n", inname, outname); if (gd.newds) wags(); /* Print data to log file, Check data */ checkds(); /* Show progress on screen */ if (gd.newds) printf("%s %s\n", gd.nucid, gd.dsid); fclose(agsfile); fclose(txtfile); } if (gd.theend) break; } fclose(in_file); goto OPENIN; } /* main */ int checkds(void) { int prev, next, i, j, ii, jj, iii, jjj; for (i = 0; i < gd.ngam; ++i) { ii = gd.inlev[i]; iii = gd.finlev[i]; /* Determine previous/next final level */ prev = 0; next = gd.nlev; if (iii > 0) prev = iii - 1; if (iii < gd.nlev - 1) next = iii + 1; for (j = i + 1; j < gd.ngam; ++j) { jj = gd.inlev[j]; jjj = gd.finlev[j]; /* Check for doubly matched gammas */ if (ii == jj && iii == jjj) { fprintf(logfile, "\n *E* Doubly matched gammas from level %5d %c %c%.2f" " to level %5d %c %c%.2f\n Eg = %.2f, %.2f\n" " Previous/next final level: %.3f %.3f and %.3f %.3f\n", ii + 1, gd.mel[ii], gd.ban[ii], gd.el[ii], iii + 1, gd.mel[iii], gd.ban[iii], gd.el[iii], gd.egam[i], gd.egam[j], gd.el[prev], gd.del[prev], gd.el[next], gd.del[next]); } } /* Check that gamma fits between levels */ chgam(gd.el[ii], gd.del[ii], gd.el[iii], gd.del[iii], gd.egam[i], gd.degam[i], gd.a, gd.el[prev], gd.del[prev], gd.el[next], gd.del[next]); /* Check gamma multipolarity against spin/parity */ chmult(gd.spin[ii], gd.parity[ii], gd.jpimod[ii], gd.spin[iii], gd.parity[iii], gd.jpimod[iii], gd.ml[i], &gd.mlpar[i], gd.mult[i], gd.egam[i], gd.el[ii], gd.el[iii], gd.d[i], gd.dd[i], gd.dd2[i], gd.el[prev], gd.del[prev], gd.el[next], gd.del[next]); } return 0; } /* checkds */ int read_ensdf(void) { double fmax, demin, etemp, detemp, deg, dle; int ngam, nlev, ilev, j, k, idum; int ij, ik, nk, nn, nscore, max, score; char ne[3], gmatch[10], *c; gd.nlev = gd.ngam = gd.nband = 0; gd.newds = 1; for (j = 0; j < MBAND; ++j) { gd.bdstr[j][0] = '\0'; } /* Read dataset */ nn = 0; while (1) { /* Loop through all cards of a data set */ if (nn >= MCARD) stopit("** Too many cards **", "Increase MCARD", "", nn); gd.card[nn][0] = '\0'; fgets(gd.card[nn], 100, in_file); if (!gd.card[nn][0]) { /* End-of-file found */ gd.theend = 1; if (nn <= 1) gd.newds = 0; return 0; } if (!strncmp(gd.card[nn], " ", 4) && nn > 0) return 0; /* End card found */ #ifdef DEBUG printf("*%d* %s", nn, gd.card[nn]); #endif /* Find out what type of card it is */ if (nn == 0) { /* Data set identification */ if (!strncmp(gd.card[0], " ", 4)) continue; /* Skip blank cards */ if (strncmp(gd.card[nn] + 5, " ", 3)) stopit("** Invalid ID card **", "", "", 0); if (gd.dsstr[0] && !strstr(gd.card[0], gd.dsstr)) { /* skip data set since it doesn't match dsstr */ while (strncmp(gd.card[0], " ", 4)) { gd.card[0][0] = '\0'; fgets(gd.card[0], 100, in_file); if (gd.card[0][0] == 0) { /* End-of-file found */ gd.theend = 1; gd.newds = 0; return 0; } } continue; } printf("\n%s", gd.card[0]); fprintf(logfile, "\n%s", gd.card[0]); strcpy(gd.dsid, gd.card[0] + 9); /* Save NUCID. Get A and Z. */ zname(gd.card[0] + 3, &gd.z, 1); strncpy(gd.nucid, gd.card[0], 5); if (gd.card[0][0] == ' ') strncpy(gd.nucid, gd.card[0]+1, 5); if (gd.card[0][1] == ' ') strncpy(gd.nucid, gd.card[0]+2, 5); sscanf(gd.nucid, "%3d", &gd.a); /* determines if ensdf dataset has odd or even A A odd/even: gd.iodd = 2/1 */ gd.iodd = 1 + gd.a%2; } else if (!strncmp(gd.card[nn] + 5, " L ", 4)) { /* Level card */ if ((nlev = gd.nlev) >= MLEV) stopit("** Too many levels **", "Increase MLEV", "", nlev); /* Save band head spin if first level in band */ for (idum = 0; idum < gd.nband; ++idum) { if (gd.card[nn][76] == gd.bd[idum]) { if (!gd.bdstr[idum][0]) { strncpy(gd.bdstr[idum], gd.card[nn] + 21, 18); gd.bdstr[idum][18] = '\0'; if (strncmp(gd.bdstr[idum], " ", 18)) gd.bdstr[idum][0] = '?'; } } } /* Get energy */ fend(gd.card[nn] + 9, ne, 10, 2); gd.el[nlev] = gd.x[0]; gd.del[nlev] = gd.x[1]; gd.mel[nlev] = ' '; gd.ban[nlev] = ' '; /* Calculate level energy if given as SP+x or SN+x */ if (spsn(gd.card[nn] + 9)) { #ifdef DEBUG printf(" LL %d %.2f %.2f\n", nlev, gd.el[nlev], gd.del[nlev]); #endif goto NEXT; } /* Save spin/parity */ getjpi(gd.card[nn] + 21, &gd.spin[nlev], &gd.parity[nlev], &gd.jpimod[nlev], &gd.joffs[nlev]); /* Check level order */ if (nlev > 0 && gd.el[nlev] < gd.el[nlev - 1] && gd.el[nlev] >= 1e-10f) { /* Allow E+X levels to be "out of order" */ if ((!(c = strstr(gd.card[nn] + 9, "+")) || c > gd.card[nn] + 18) && (!(c = strstr(gd.levcard[nlev - 1] + 9, "+")) || c > gd.levcard[nlev - 1] + 18)) stopit(gd.card[nn], gd.levcard[nlev - 1], "** Level out of order **", 0); } /* Save card pointer for later use */ gd.levcard[nlev] = gd.card[nn]; /* Left justify for FL= matching */ for (ij = 10; ij < 20; ++ij) { if (gd.card[nn][9] != ' ') break; strncpy(gd.card[nn] + 9, gd.card[nn] + 10, 9); gd.card[nn][18] = ' '; } /* +X goes to MEL array */ /* Check for exponent, SP or SN */ if ((c = strstr(gd.card[nn] + 9, "+")) && c < gd.card[nn] + 20 && *(c--) != 'E') { if (!strstr(gd.card[nn], "SP") && !strstr(gd.card[nn], "SN")) { /* Check for X+ */ if (!NUMB(*c) && *c != ' ') gd.mel[nlev] = *c; /* Check for +X */ c += 2; if (!NUMB(*c) && *c != ' ') gd.mel[nlev] = *c; } } else { /* Check for letter by itself; look at first non-blank character*/ for (c = gd.card[nn] + 9; c < gd.card[nn] + 19; c++) { if (*c == ' ') continue; if (!NUMB(*c) && *c != '+' && *c != '-' && *c != '.') gd.mel[nlev] = *c; break; } } #ifdef DEBUG printf(" ll %d E:%.2f+-%.2f J:%d%c mel:%c joffs:%c\n", nlev, gd.el[nlev], gd.del[nlev], gd.spin[nlev], gd.parity[nlev], gd.mel[nlev], gd.joffs[nlev]); #endif gd.unclev[nlev] = gd.card[nn][79]; /* Set stucture flag in col. 3 and other flags on FLAG= cont. card */ /* Check if band with col. 77 tag is defined */ if (gd.card[nn][76] != ' ') { for (ij = 0; ij < gd.nband; ++ij) { if (gd.bd[ij] == gd.card[nn][76]) { gd.ban[nlev] = gd.bd[ij]; break; } } } /* Increment number of levels */ ++gd.nlev; } else if (!strncmp(gd.card[nn] + 5, " Q ", 4)) { /* Q card */ /* Put Nucid in SNucId */ zname(gd.card[nn] + 3, &idum, 1); strncpy(gd.snucid, gd.card[nn], 5); /* Save SP and SN with uncertainties */ fend(gd.card[nn] + 21, ne, 8, 2); gd.sn = gd.x[0]; gd.dsn = gd.x[1]; fend(gd.card[nn] + 31, ne, 8, 2); gd.sp = gd.x[0]; gd.dsp = gd.x[1]; } else if (!strncmp(gd.card[nn] + 5, " G ", 4)) { /* Gamma card */ /* Ignore unplaced gammas and decay from levels with E=0 */ if (gd.nlev == 0) goto NEXT; ilev = gd.nlev - 1; /* initial level id */ if (gd.el[ilev] <= 0.0) { fprintf(logfile, "\n*E* Gamma depopulating level with E <= 0\n" " Gamma %.10s from level %.10s ignored\n", gd.card[nn] + 9, gd.levcard[ilev] + 9); goto NEXT; } ngam = gd.ngam++; if (ngam >= MGAM) stopit("** Too many gammas **", "Increase MGAM", "", ngam); gd.inlev[ngam] = gd.nlev - 1; gd.unctr[ngam] = gd.card[nn][79]; /* Get energy, default DE for matching is 1 keV */ fend(gd.card[nn] + 9, ne, 10, 2); gd.egam[ngam] = gd.x[0]; gd.degam[ngam] = gd.x[1]; deg = gd.degam[ngam]; if (gd.degam[ngam] < 1e-10) deg = 1.f; etemp = gd.el[ilev] - gd.egam[ngam]; dle = gd.del[ilev]; if (dle < 1e-10) dle = 1.f; detemp = sqrt(deg * deg + dle * dle); /* Get intensity */ fend(gd.card[nn] + 21, ne, 8, 2); gd.igam[ngam] = gd.x[0]; gd.digam[ngam] = gd.x[1]; #ifdef DEBUG printf(" gg %d E:%.3f+-%.3f I:%.2f+-%.2f Ef:%.2f+-%.2f +%c\n", gd.ngam, gd.egam[ngam], gd.degam[ngam], gd.igam[ngam], gd.digam[ngam], etemp, detemp, gd.mel[ilev]); #endif /* Get multipolarity */ strncpy(gd.mult[ngam], gd.card[nn] + 31, 10); getml(gd.mult[ngam], gd.ml[ngam], gd.mlpar + ngam); /* Get mixing ratio */ fend(gd.card[nn] + 41, ne, 8, 6); gd.d[ngam] = gd.x[0]; gd.dd[ngam] = gd.x[1]; gd.dd2[ngam] = gd.x[2]; demin = 1e3f; max = nscore = 0; /* Score match on basis of energy, Mult-JPi, band assignment, and +XYZ*/ for (ij = 0; ij < ilev; ++ij) { /* Test only cases where +XYZ are identical or absent */ if (gd.mel[ij] != gd.mel[ilev]) continue; score = escore(etemp, detemp, gd.el[ij], gd.del[ij]); /* If no energy match give up and try again */ if (score == 0) continue; /* Check for common band assignment, add 2 to score */ if (gd.ban[ilev] != ' ' && gd.ban[ilev] == gd.ban[ij]) score += 2; /* Check for consistent multipolarity and JPI:s */ score += mjscor(gd.card[nn] + 31, gd.levcard[ilev] + 21, gd.levcard[ij] + 21); if (score <= 0) continue; if (score > nscore || (score == nscore && fabs(etemp - gd.el[ij]) < demin)) { /* Two levels with different score, choose best score, or Two levels with same score, choose closest */ max = ij; demin = fabs(etemp - gd.el[max]); nscore = score; } } /* MAX is level with best fit (highest score) */ #ifdef DEBUG printf(" ...FinalLev:%d score:%d\n", max, nscore); #endif if (nscore <= 0) { /* If no fits get a score, write to output file for further review and choose closest level */ max = match(etemp, gd.el, gd.nlev) - 1; /* Make sure final level is not initial level */ if (max == ilev) max = (ilev > 1 ? ilev - 1 : 0); gd.finlev[ngam] = max; /* If closest level is only reasonable fit, all is OK */ fmax = detemp * 5.f; if (fmax < 5.f) fmax = 5.f; if (max < 0 || gd.el[max + 1] - gd.el[max] <= fmax || (max > 0 && gd.el[max] - gd.el[max - 1] <= fmax)) goto NEXT; #ifdef DEBUG printf(" ...NewFinalLev:%d\n", max); #endif } gd.finlev[ngam] = max; } else if (!strncmp(gd.card[nn] + 6, " G ", 3) && (c = strstr(gd.card[nn], "FL="))) { /* Final level flag (FL=) on gamma continuation card */ c += 2; memset(gmatch, ' ', 10); nk = 0; for (k = 0; k < 12; ++k) { /* Skip blanks. Put FL value left justified in GMATCH */ if (*(++c) == '$') break; if (*c == '?') goto NEXT; if (*c != ' ') gmatch[nk++] = *c; } /* Compare previous levels with GMATCH */ for (ij = 0; ij < gd.nlev - 1; ++ij) { if (!strncmp(gd.levcard[ij] + 9, gmatch, 10)) { /* Match found */ gd.finlev[gd.ngam - 1] = ij; goto NEXT; } } /* Error message for no match found */ fprintf(logfile, "\n *E* No FL=%.10s match for %.22s\n", gmatch, gd.card[nn - 1]); } else if (!strncmp(gd.card[nn] + 5, " CL BAND(", 9) || !strncmp(gd.card[nn] + 5, " cL BAND(", 9)) { /* Band (level) comment */ c = gd.card[nn] + 13; for (j = 0; j < 10; ++j) { c++; if (*c == ')' || *c == ' ') goto NEXT; if (*c != ',') { if (gd.nband >= MBAND) stopit("** Too many bands **", "Increase MBAND", "", gd.nband); gd.bd[gd.nband] = *c; /* Clear band head JPi field */ gd.bdstr[gd.nband][0] = '\0'; /* Save comment text as band identification */ ij = INDEX(gd.card[nn], "$"); if (ij < 1 || ij > 19) ij = 19; strcpy(gd.bandid[gd.nband], gd.card[nn] + ij); gd.bandid[gd.nband][63] = '\0'; ++gd.nband; } } } else if (!strncmp(gd.card[nn] + 6, " L ", 3) && (c = strstr(gd.card[nn], "FLAG="))) { /* Band flag on level continuation card (FLAG=) */ nlev = gd.nlev - 1; if (gd.ban[nlev] != ' ') goto NEXT; c += 4; for (ij = 0; ij < 9; ++ij) { if (*(++c) == '$') goto NEXT; if (*c != ' ' && *c != ',') { for (ik = 0; ik < gd.nband; ++ik) { if (gd.bd[ik] == *c) { gd.ban[nlev] = gd.bd[ik]; /* Save band head spin if first level in band */ if (!gd.bdstr[ik][0]) { strncpy(gd.bdstr[ik], gd.levcard[nlev] + 21, 18); gd.bdstr[ik][18] = '\0'; if (strncmp(gd.bdstr[ik], " ", 18)) gd.bdstr[ik][0] = '?'; } goto NEXT; } } } } } NEXT: ++nn; } return 0; } /* read_ensdf */ int escore(double e, double de, double x, double dx) { double z, dz; int mez = 0, score = 0; /* Decide on final level for gamma Score energy. Small uncertainty, small deviation adds 9 to score Calculate uncertainty in deviation */ dz = sqrt(de * de + dx * dx); if (dz < 1e-4f) dz = 1.0; /* Z is deviation in sigmas */ z = fabs((e - x) / dz); /* Relax constraint for precise energy matches */ if (fabs(e - x) < 0.03 && z > 1.0) z = 1.0; if (dz > 10.0) { /* DZ is >10. No score if Z > 2 sigma */ if (z > 2.0) return 0; mez = 4; } else if (dz > 4.0) { /* DZ is 4-10. No score if Z > 2 sigma */ if (z > 2.0) return 0; mez = 2; } else { /* DZ is 0-4. No score if Z > 3 sigma */ if (z > 3.0) return 0; score = 2; } if (z < 2.0) score = 5 - mez; if (z < 1.0) score = 7 - mez; if (z < 0.3) score = 9 - mez; /* return energy score */ return score; } /* escore */ int mjscor(char *mull, char *mj1, char *mj2) { /* Initialized data */ static char *mel[15] = {"E1", "M2", "E3", "M4", "E5", "E0", "M1", "E2", "M3", "E4", "M5", "E6", "D", "Q", "O" }; static char iblank[] = " "; int nmat, i, j, l, jspin[5], kspin[5], n1, n2, jt, ldq, score = 0; char jpar[5], kpar[5], mjp[5], mul[16], *c, ic[24]; /* This subroutine matches multipolarity to initial and final spins Score 0 for partial match, 7 for complete match and -7 for mismatch No score if any of the spin fields is empty */ if (!strncmp(mj1, iblank, 18) || !strncmp(mj2, iblank, 18)) return 0; strncpy(mul, mull, 10); mul[10] = '\0'; /* Treat no multipolarity as Quadrupole */ if (!strcmp(mul, " ")) strcpy(mul, " Q "); /* No score if multipolarity is based on spins (IF or []) */ if (strstr(mul, "IF") || strstr(mul, "[")) return 0; jt = -1; for (l = 0; l < 15; ++l) { if (strstr(mul, mel[l])) break; } if (++l > 15) { /* No match found, return */ jt = 0; return 0; } ldq = 0; /* Dipole/quadrupole/octupole */ if (l > 12) ldq = 1; if (l == 13) l = 1; if (l == 14) l = 2; if (l == 15) l = 3; if (l > 5) { l -= 6; jt = 1; } /* JT=1 for no parity change. JT=0 for parity change. L is multipolarity*/ /* Double multipolarity to handle half-int spins */ l *= gd.iodd; nmat = 0; /* MJ1 and MJ2 are the inital and final level spin fields respectively */ strncpy(ic, mj1, 18); ic[18] = '\0'; if ((c = strstr(ic, "J+")) || (c = strstr(ic, "+J"))) { strncpy(c, " ", 2); /* mj1 has a spin offset; check that mj2 has one too */ if (!strstr(mj2, "J+") && !strstr(mj2, "+J")) return 0; } jread(ic, jspin, jpar, mjp, &n1); strncpy(ic, mj2, 18); ic[18] = '\0'; if ((c = strstr(ic, "J+")) || (c = strstr(ic, "+J"))) strncpy(c, " ", 2); jread(ic, kspin, kpar, mjp, &n2); /* PROCESS D, Q, O */ if (ldq) { for (i = 0; i < n1; ++i) { for (j = 0; j < n2; ++j) { if (abs(jspin[i] - kspin[j]) <= l) ++nmat; } } } else { /* Assume M2 and higher multipoles are stretched */ for (i = 0; i < n1; ++i) { for (j = 0; j < n2; ++j) { if (l > (gd.iodd << 1) || (l == (gd.iodd << 1) && jt == -1)) { if (jspin[i] - l != kspin[j] && jspin[i] + l != kspin[j]) continue; } else { if (jspin[i] - l > kspin[j] || jspin[i] + l < kspin[j]) continue; } if ((jt == 0 || jpar[i] == ' ' || kpar[j] == ' ') || (jt == 1 && jpar[i] != kpar[j]) || (jt == -1 && jpar[i] == kpar[j])) continue; ++nmat; break; } } } /* Score 0 for partial match, 7 for complete match and -7 for mismatch */ if (nmat == n1) score = 7; if (nmat == 0) score = -7; return score; } /* mjscor */ int spsn(char *str) { float kratio; if (strstr(str, "SP")) { /* Make sure Sp for the correct nucleus is used */ if (strncmp(gd.nucid, gd.snucid, 5)) { fprintf(logfile, "\n *E* Incorrect Sp. Add Q card.\n" " Level=%12.3f+Sp skipped\n", gd.el[gd.nlev - 1]); return 1; } /* KRatio = Kinematic ratio for reaction (A(target)/A(comp.nucl.) */ kratio = iget(gd.dsid) / (float) gd.a; gd.el[gd.nlev - 1] = gd.sp + kratio * gd.x[0]; gd.del[gd.nlev - 1] = sqrt(gd.dsp * gd.dsp + gd.x[1] * gd.x[1]); } else if (strstr(str, "SN")) { /* Make sure Sn for the correct nucleus is used */ if (strncmp(gd.nucid, gd.snucid, 5)) { fprintf(logfile, "\n *E* Incorrect Sn. Add Q card.\n" " Level=%12.3f+Sn\n skipped", gd.el[gd.nlev - 1]); return 1; } kratio = iget(gd.dsid) / (float) gd.a; gd.el[gd.nlev - 1] = gd.sn + kratio * gd.x[0]; gd.del[gd.nlev - 1] = sqrt(gd.dsn * gd.dsn + gd.x[1] * gd.x[1]); } return 0; } /* spsn */ int label(int ll, int iband, int n, char *name) { int i, ispin; char c, dum[8]; /* Get name for level ll for WAGS. ll is level number, n is level number in band, name is the generated label */ strncpy(name, gd.nucid, 5); /* remove trailing blanks from name */ for (i = 0; ((name[4] == ' ' || name[4] == '\0') && i < 4); i++) { strncpy(dum, name, 4); name[0] = ' '; strncpy(name + 1, dum, 4); } if (gd.ban[ll] != ' ') { /* Band level, band number iband, level number n */ name[5] = gd.bdpi[iband]; name[6] = gd.bd[iband]; if (gd.spin[ll] >= 0) { /* Known spin */ if (gd.joffs[ll] == ' ') { /* No J offset */ ispin = gd.spin[ll] / gd.iodd; sprintf(name + 8, "%.2d", ispin); } else { /* With J offset */ ispin = (gd.bdk[iband] + n * gd.bdstep[iband]) / gd.iodd; if (ispin >= 0) { sprintf(name + 8, "%.2d", ispin); if (ispin == 0 && gd.iodd == 2) strncpy(name + 8, "-0", 2); } else { strncpy(name + 8, "-1", 2); } } } else { /* Unknown spin */ ispin = (gd.bdk[iband] + n * gd.bdstep[iband]) / gd.iodd; if (ispin >= 0) { sprintf(name + 8, "%.2d", ispin); if (ispin == 0 && gd.iodd == 2) strncpy(name + 8, "-0", 2); } else { strncpy(name + 8, "-1", 2); } } name[7] = 'O'; if ((ispin / 2) << 1 == ispin) name[7] = 'E'; } else { /* Non-band level, level number 0 */ name[5] = gd.parity[ll]; if (name[5] == ' ') name[5] = '?'; /* Imbed character equivalent of ll in name */ /* use 0-9, A-Z, a-z */ c = '0' + (char) (ll / 62); if (c > '9') c += 'A' - '9'; if (c > 'Z') c += 'a' - 'Z'; name[6] = c; c = '0' + (char) (ll % 62); if (c > '9') c += 'A' - '9'; if (c > 'Z') c += 'a' - 'Z'; name[7] = c; ispin = gd.spin[ll] / gd.iodd; if (ispin >= 0) { sprintf(name + 8, "%.2d", ispin); if (ispin == 0 && gd.iodd == 2) strncpy(name + 8, "-0", 2); } else { strncpy(name + 8, "-1", 2); } } return 0; } /* label */ int levstat(char unclev, int ispin, char parity, char jpimod, char joffs) { /* Determine level uncertainty status variable (itent) for AGS format from UncLev and JPiMod: RtnVal RadwareLabel JPiMod Ispin parity 0 J Pi ' ' >= 0 ne ' ' 1 (J) Pi 'J' >= 0 ne ' ' 2 J (Pi) 'P' >= 0 ne ' ' 3 (J Pi) 'B' >= 0 ne ' ' 4 J ' ' >= 0 ' ' 5 (J) 'J' >= 0 ' ' 6 none any < 0 any Joffs ne ' ' gives label 6 */ if (joffs != ' ' || ispin < 0) return 6; if (parity == ' ' && jpimod == 'J') return 5; if (parity == ' ' && jpimod == ' ') return 4; if (parity != ' ' && jpimod == 'B') return 3; if (parity != ' ' && jpimod == 'P') return 2; if (parity != ' ' && jpimod == 'J') return 1; if (parity != ' ' && jpimod == ' ') return 0; return 6; } /* levstat */ int bdprop(void) { int bsok, lastspin, i, j, idiff, count; char *c; /* Determine band properties (parity, spin step) for a band. The parameters are mainly used for the naming of levels by WAGS. */ for (j = 0; j < gd.nband; ++j) { /* Define default band properties */ bsok = 0; gd.bdpi[j] = '?'; gd.bdk[j] = -1; gd.bdstep[j] = gd.iodd << 1; count = 0; lastspin = -99; for (i = 0; i < gd.nlev; ++i) { if (i < 0) continue; if (gd.ban[i] == gd.bd[j]) { /* Parity of band determined by first parity given */ if (gd.parity[i] != ' ' && gd.bdpi[j] == '?') gd.bdpi[j] = gd.parity[i]; /* BdStep is 1 or 2. Determined by first spin difference. BdK is calculated from this or from spin of first level */ if (++count == 1) { gd.ioffs[j] = 0; /* Get J offset if given */ if (gd.joffs[i] != ' ') { /* Read the first number in gd.bdstr[j] */ for (c = gd.bdstr[j]; *c != '\0'; ++c) { if (NUMB(*c)) { gd.ioffs[j] = iget(c); break; } } #ifdef DEBUG printf(" Bandhead spin for band %c : %s > %d\n", gd.bd[j], gd.bdstr[j], gd.ioffs[j]); #endif if (gd.ioffs[j] <= 0) gd.ioffs[j] = -1; } if (gd.spin[i] >= 0) { gd.bdk[j] = gd.spin[i] + gd.ioffs[j]; } else { gd.bdk[j] = gd.spin[i]; } } if (count >= 2) { idiff = gd.spin[i] - lastspin; if (idiff < 0) idiff = -idiff; if ((idiff / gd.iodd == 1 || idiff / gd.iodd == 2) && !bsok) { gd.bdstep[j] = idiff; if (gd.iodd == 2 && gd.joffs[i] != ' ') gd.bdstep[j] <<= 1; if (gd.bdk[j] < 0 && gd.joffs[i] == ' ') gd.bdk[j] = gd.spin[i] - (count - 1)*gd.bdstep[j]; bsok = 1; } } if (gd.spin[i] >= 0) lastspin = gd.spin[i]; } } } return 0; } /* bdprop */ int bandcheck(void) { int i, j; /* Check for duplicate labels */ for (i = 0; i < gd.nlev - 1; ++i) { for (j = i + 1; j < gd.nlev; ++j) { if (!strncmp(gd.levlab[i], gd.levlab[j], 10)) { fprintf(logfile, "\n *E* Duplicate label %.10s for levels at %.3f %.3f\n", gd.levlab[i],gd.el[i], gd.el[j]); } } } /* Check parities */ for (j = 0; j < gd.nband; ++j) { for (i = 0; i < gd.nlev; ++i) { if (gd.ban[i] == gd.bd[j] && gd.bdpi[j] != '?' && gd.parity[i] != ' ' && gd.parity[i] != gd.bdpi[j]) fprintf(logfile, "\n *E* Band parity %c deviates from level %.3f parity %c\n", gd.bdpi[j], gd.el[i], gd.parity[i]); } } return 0; } /* bandcheck */ /*#############################################################*/ /* str77 */ int iget(char *str) { int ret_val = 0; char *c; /* convert the input string str into an int (function value) only digits preceeding the first non-numeric character are converted */ if (!strlen(str)) return 0; c = str; if (*c == '-' || *c == '+') c++; while (NUMB(*c)) { ret_val *= 10; ret_val += (int) (*(c++) - '0'); } if (*str == '-') return -ret_val; return ret_val; } /* iget */ int getjpi(char *jpi, int *spin, char *parity, char *jpimod, char *joffs) { int i, j[5], l; char *c, card[24], mjpi[5], pi[5]; strncpy(card, jpi, 18); card[18] = '\0'; /* Find and remove string 'J+', '+J' or 'J' */ *spin = -1; *parity = *jpimod = *joffs = ' '; if ((c = strstr(card, "J+")) || (c = strstr(card, "+J"))) { *joffs = 'J'; strncpy(c, " ", 2); } else if (strstr(card, "J")) { *joffs = 'J'; *spin = 0; return 0; } if (!jread(card, j, pi, mjpi, &l) && l == 1) { *spin = j[0]; *parity = pi[0]; *jpimod = mjpi[0]; } else if (l > 0) { *parity = pi[0]; for (i = 0; i < l; ++i) { if (mjpi[i] == 'B' || mjpi[i] == 'P') *jpimod = 'P'; if (pi[i] != pi[0]) *parity = ' '; } } return 0; } /* getjpi */ int putjpi(char *jpi, int spin, char parity, char jpimod) { char dumstr[16], *c; if (spin < 0 && parity == ' ') { strcpy(jpi, " "); return 0; } strcpy(jpi, "**********"); /* 1234567890 (JJJ/2)(P) or JJJ+J Write spin */ if (spin >= 0) sprintf(jpi + 1, "%3d", spin); if (jpi[1] == ' ') jpi[1] = '*'; if (jpi[2] == ' ') jpi[2] = '*'; /* Add /2 or +J when applicable */ if (gd.iodd == 2 && spin >= 0) strncpy(jpi + 4, "/2", 2); /* if (joffs != ' ') strncpy(jpi + 4, "+J", 2); */ /* Add parity */ if (parity != ' ') jpi[8] = parity; /* Add appropriate parenthesies */ if (jpimod == 'J' || jpimod == 'B') jpi[0] = '('; if (jpimod == 'J') jpi[6] = ')'; if (jpimod == 'P' || jpimod == 'B') jpi[9] = ')'; if (jpimod == 'P') jpi[7] = '('; /* Squeeze out *:s */ while ((c = strstr(jpi, "*"))) { strcpy(dumstr, c + 1); strcpy(c, dumstr); strcat(c, " "); } return 0; } /* putjpi */ int getml(char *mult, int *ml, char *parity) { int n1 = 0, n2 = 0, le, nd, ne, lm, nm, no, nq; char pare, parm; /* Get lowest two multipolarities from ENSDF Mult field and store L-values and parity in ML(2) and parity. M1/E2: 1,2 '+' Pure E2: 2,-1 '+' M2/E3: 2,3 '-' E0/M1: 0,1 '+' Reset multipolarity variables */ lm = le = 0; ml[0] = ml[1] = -1; *parity = ' '; /* Empty field - return */ if (!strncmp(mult, " ", 10)) return 0; /* Field containing NOT - return */ if (strstr(mult, "NOT")) return 0; /* Find the first two multipolarities in mult string */ ne = INDEX(mult, "E"); if (ne > 0 && !NUMB(mult[ne])) ne = 0; nm = INDEX(mult, "M"); if (nm > 0 && !NUMB(mult[nm])) nm = 0; pare = parm = ' '; /* Get electric multipole and parity */ if (ne > 0) { sscanf(mult + ne, "%d", &le); if (le < 0 || le > 6) return 1; if ((le / 2) << 1 == le) { pare = '+'; } else { pare = '-'; } } /* Get magnetic multipole and parity */ if (nm > 0) { sscanf(mult + nm, "%d", &lm); if (lm <= 0 || le > 6) return 1; if ((lm + 1) / 2 << 1 == lm) { parm = '-'; } else { parm = '+'; } } /* Make sure parity from El and Ml are consistent */ if (parm != ' ') { *parity = parm; if (pare != ' ' && pare != parm) return 1; } else if (pare != ' ') { *parity = pare; } /* Get multipolarities Two multipolarities */ if (ne > 0 && nm > 0) { if (le < lm) { ml[0] = le; ml[1] = lm; n1 = ne; n2 = nm; } else { ml[0] = lm; ml[1] = le; n1 = nm; n2 = ne; } /* One, magnetic */ } else if (nm > 0) { ml[0] = lm; n1 = nm; n2 = 99; /* One electric */ } else if (ne > 0) { ml[0] = le; n1 = ne; n2 = 99; } /* Handle D, Q and O */ if (ne == 0 && nm == 0) { nd = INDEX(mult, "D"); nq = INDEX(mult, "Q"); no = INDEX(mult, "O"); if (nd > 0) { ml[0] = 1; if (nq > 0) ml[1] = 2; n1 = nd; n2 = nq; } else if (nq > 0) { ml[0] = 2; if (no > 0) ml[1] = 3; n1 = nq; n2 = no; } else if (no > 0) { /* fixed from fconv.f: was if (nq > 0) */ ml[0] = 3; n1 = no; n2 = 99; } } return 0; } /* getml */ int jread(char *icard, int *j, char *pi, char *mjpi, int *l) { int jpar, i, k, m, n, kk, ll, rtn_val = 0; char ic[24]; /* Subroutine to read ENSDF JPI field and return array of J and PI values and alphanumeric modifier. icard contains input spin field, j(5) and pi(5) are the returned spin and parity values (up to 5), and l is the number of spins returned. J=-1 for a blank spin (e.g. only parity given). JPI = J / P / B : spin / parity / both in parenthesis */ strncpy(ic, icard, 18); ic[18] = '\0'; *l = 0; for (k = 0; k < 5; ++k) { j[k] = -1; pi[k] = mjpi[k] = ' '; } if (!strcmp(ic, " ")) return 1; /* Check for odd-ball contents */ if (strstr(ic, "OR") || strstr(ic, "AND") || strstr(ic, "&") || strstr(ic, "AP") || strstr(ic, "LE") || strstr(ic, "GE") || strstr(ic, "LT") || strstr(ic, "GT") || strstr(ic, "NOT") || strstr(ic, "+X") || strstr(ic, "+Y") || strstr(ic, "+Z") || strstr(ic, ">") || strstr(ic, "<") || strstr(ic, "TO") || strstr(ic, ":") || strstr(ic, "NAT") || strstr(ic, "J") || strstr(ic, "P") || strstr(ic, "HI")) return 2; jpar = m = n = ll = 0; for (i = 0; i < 18; ++i) { if (ic[i] == ' ' || ic[i] == '/') continue; if (i > 0 && ic[i] == '2' && ic[i - 1] == '/') continue; if (ic[i] == '(' || ic[i] == '[') { jpar = 1; m = ll + 1; } else if (ic[i] == ')' || ic[i] == ']') { jpar = 0; n = ll + 1; } else if (ic[i] == ',' || ic[i] == 'O' || ic[i] == 'A') { ++ll; } else if (ic[i] == '-' || ic[i] == '+') { pi[ll] = ic[i]; if (jpar == 1) { if (mjpi[ll] == 'J') mjpi[ll] = 'B'; if (mjpi[ll] == ' ') mjpi[ll] = 'P'; } if (m == 0) continue; for (kk = m - 1; kk < n; ++kk) { pi[kk] = ic[i]; } m = 0; n = 0; } else { k = ((int) ic[i]) - ((int) '0'); if (k < 0 || k > 9) { printf(" ** Illegal JPI field: %.18s\n", ic); fprintf(logfile, "\n ** Illegal JPI field: %.18s\n", ic); rtn_val = 1; } else { if (j[ll] < 0) { j[ll] = k; } else if (j[ll] >= 0) { j[ll] = j[ll] * 10 + k; } if (jpar == 1) mjpi[ll] = 'J'; } } } *l = ll + 1; return rtn_val; } /* jread */ int fend(char *ic1, char *mx, int len1, int len2) { int i, n, m1, jj, ml, mm, nq, iii; char *ic2, *c, jc[24], kc[24], jbl[24]; /* Decode ENSDF data into numeric data and store in gd.x */ ic2 = ic1 + len1; memset(mx, ' ', 3); memset(jbl, ' ', 20); memset(kc, ' ', 20); gd.x[0] = gd.x[1] = gd.x[2] = 0.f; /* Blank value - return */ if (!strncmp(ic1, jbl, len1)) return 0; /* Check for nonnumeric quantities */ strncpy(jc, ic1, len1); jc[len1] = '\0'; while (1) { if ((c = strstr(jc, "+")) && c > jc && *(c - 1) != 'E') { if (!NUMB(*(c+1))) { /* following character is not a number */ strncpy(mx, c, 2); strncpy(c, " ", 2); if (c + 2 < jc + len1 && *(c + 2) != ' ') { mx[2] = *(c + 2); *(c + 2) = ' '; } break; } /* following character is a number */ strncpy(mx + 1, c - 1, 2); strncpy(c - 1, " ", 2); if (c - 2 >= jc && *(c - 2) != ' ') { mx[0] = *(c - 2); *(c - 2) = ' '; } } else if ((c = strstr(jc, "?"))) { *c = ' '; strncpy(mx, " ?", 3); } else if ((c = strstr(jc, "("))) { *c = ' '; strncpy(mx, " ()", 3); if ((c = strstr(jc, ")"))) *c = ' '; } else if ((c = strstr(jc, "X"))) { strncpy(c, "0+X", 3); continue; } else if ((c = strstr(jc, "Y"))) { strncpy(c, "0+Y", 3); continue; } else if ((c = strstr(jc, "SN")) || (c = strstr(jc, "SP"))) { strncpy(c, " ", 2); strncpy(mx + 1, c, 2); continue; } break; } if ((sscanf(jc, "%lf", &gd.x[0])) != 1) { iii = 0; for (i = 0; i < len1; ++i) { if (NUMB(jc[i]) || jc[i] == '.') continue; jc[i] = ' '; if (iii < 2) mx[iii] = jc[i]; ++iii; } } /* Check uncertainties for alphanumerics */ jj = 0; if (!strncmp(ic2, jbl, len2)) return 0; for (i = 0; i < len2; ++i) { if (ic2[i] == '-' || ic2[i] == '+') continue; if (ic2[i] != ' ' && !NUMB(ic2[i])) return 0; if (NUMB(ic2[i])) jj = i + 1; } if (jj == 0) return 0; while (1) { /* Process uncertainties */ mm = len1; nq = 0; if ((c = strstr(jc, "E")) || (c = strstr(jc, "e"))) { mm = c - jc; strncpy(kc + mm, c, len1 - mm); } m1 = 2; for (i = 1; i <= mm; ++i) { n = mm - i; if (jc[n] == ' ' || jc[n] == '.') { kc[n] = jc[n]; continue; } kc[n] = '0'; if (nq == 1) continue; while (jj > 0) { if (ic2[--jj] != ' ') { kc[n] = ic2[jj]; break; } } if (jj <= 0 || ic2[jj - 1] == '-' || ic2[jj - 1] == '+') nq = 1; } sscanf(kc, "%lf", &gd.x[m1 - 1]); if (m1 == 3 || gd.x[2] > 1e-20) return 0; if ((jj <= 0) || (ic2[jj - 1] != '-' && ic2[jj - 1] != '+')) { gd.x[2] = gd.x[1]; return 0; } if (ic2[jj - 1] == '+') { m1 = 3; } else { gd.x[2] = gd.x[1]; gd.x[1] = 0.f; ml = 2; } strncpy(kc, jbl, 20); --jj; nq = 0; } } /* fend */ int zname(char *el, int *z, int iopt) { /* Initialized data */ static char nz[2*110] = "H " "HE" "LI" "BE" "B " "C " "N " "O " "F " "NE" "NA" "MG" "AL" "SI" "P " "S " "CL" "AR" "K " "CA" "SC" "TI" "V " "CR" "MN" "FE" "CO" "NI" "CU" "ZN" "GA" "GE" "AS" "SE" "BR" "KR" "RB" "SR" "Y " "ZR" "NB" "MO" "TC" "RU" "RH" "PD" "AG" "CD" "IN" "SN" "SB" "TE" "I " "XE" "CS" "BA" "LA" "CE" "PR" "ND" "PM" "SM" "EU" "GD" "TB" "DY" "HO" "ER" "TM" "YB" "LU" "HF" "TA" "W " "RE" "OS" "IR" "PT" "AU" "HG" "TL" "PB" "BI" "PO" "AT" "RN" "FR" "RA" "AC" "TH" "PA" "U " "NP" "PU" "AM" "CM" "BK" "CF" "ES" "FM" "MD" "NO" "LR" "RF" "DB" "SG" "BH" "HS" "MT" "10"; static char lnz[2*110] = "H " "He" "Li" "Be" "B " "C " "N " "O " "F " "Ne" "Na" "Mg" "Al" "Si" "P " "S " "Cl" "Ar" "K " "Ca" "Sc" "Ti" "V " "Cr" "Mn" "Fe" "Co" "Ni" "Cu" "Zn" "Ga" "Ge" "As" "Se" "Br" "Kr" "Rb" "Sr" "Y " "Zr" "Nb" "Mo" "Tc" "Ru" "Rh" "Pd" "Ag" "Cd" "In" "Sn" "Sb" "Te" "I " "Xe" "Cs" "Ba" "La" "Ce" "Pr" "Nd" "Pm" "Sm" "Eu" "Gd" "Tb" "Dy" "Ho" "Er" "Tm" "Yb" "Lu" "Hf" "Ta" "W " "Re" "Os" "Ir" "Pt" "Au" "Hg" "Tl" "Pb" "Bi" "Po" "At" "Rn" "Fr" "Ra" "Ac" "Th" "Pa" "U " "Np" "Pu" "Am" "Cm" "Bk" "Cf" "Es" "Fm" "Md" "No" "Lr" "Rf" "Db" "Sg" "Bh" "Hs" "Mt" "10"; int i; /* IOPT=0: Determine Z from element symbol EL. IOPT=1: Determine Z from element symbol EL, replace EL. IOPT=2: Determine element symbol from Z (Z-100 for Z>109). IOPT=3: Determine element symbol from Z (Z-100 for Z>103). Get Z from EL */ if (iopt <= 1) { /* Make sure element symbol is left justified */ if (*el == ' ') { *el = el[1]; el[1] = ' '; } /* Element symbol is number: Z = symbol + 100 */ if (NUMB(el[0]) && NUMB(el[1])) { sscanf(el, "%d", z); *z += 100; } else { *z = 0; for (i = 0; i < 109; ++i) { if (!strncmp(nz + (i << 1), el, 2) || !strncmp(lnz + (i << 1), el, 2)) *z = i + 1; } } /* For IOPT=1, replace EL with proper element symbol */ if (iopt == 1) { if (*z > 0 && *z < 110) { strncpy(el, lnz + ((*z - 1) << 1), 2); } else if (*z >= 110 && *z < 200) { sprintf(el, "%.2d", *z - 100); } else { strncpy(el, " ", 2); } } } else if (iopt == 2) { if (*z <= 0 || *z >= 200) { strncpy(el, " ", 2); } else if (*z <= 109) { strncpy(el, lnz + ((*z - 1) << 1), 2); } else if (*z > 109) { sprintf(el, "%.2d", *z - 100); } } else if (iopt == 3) { if (*z <= 0 || *z >= 200) { strncpy(el, " ", 2); } else if (*z <= 103) { strncpy(el, nz + ((*z - 1) << 1), 2); } else if (*z > 103) { sprintf(el, "%.2d", *z - 100); } } return 0; } /* zname */ int stopit(char *str1, char *str2, char *str3, int number) { /* Flags fatal errors and stops execution */ fprintf(logfile, "\n ***** Fatal error *****\n" " Dataset/Last card/message/number:\n" "%s", gd.card[0]); if (*str1) fprintf(logfile, " %s\n", str1); if (*str2) fprintf(logfile, " %s\n", str2); if (*str3) fprintf(logfile, " %s\n", str3); if (number) fprintf(logfile, "%d\n", number); printf("\n ***** Fatal error *****\n" " Dataset/Last card/message/number:\n" "%s", gd.card[0]); if (*str1) printf(" %s\n", str1); if (*str2) printf(" %s\n", str2); if (*str3) printf(" %s\n", str3); if (number) printf("%d\n", number); exit(0); } /* stopit */ int chgam(double ein, double dein, double efi, double defi, double eg, double deg, int a, double elo, double delo, double ehi, double dehi) { float r1, diff, aa, dl, uncgam, ddl, rec, err; /* Make sure that gamma fits level energy difference. For recoil correction feed mass number as parameter A, for no recoil correction feed 999999. Errors are logged to unit 4. */ aa = (float) a; /* If A unknown, take a reasonable value */ if (a <= 1) aa = 100.f; /* Skip if level uncertainty not given except for G.S. */ if (dein < 1e-6f) return 0; if (defi < 1e-6f && efi > 1e-6f) return 0; /* Use 1 keV as default Eg uncertainty */ uncgam = deg; if (deg < 1e-6f) uncgam = 1.f; dl = ein - efi; ddl = sqrt(dein * dein + defi * defi); err = sqrt(ddl * ddl + uncgam * uncgam); /* Calculate recoil correction */ rec = eg * eg / (aa * 1863003.2f); diff = fabs(dl - eg - rec); r1 = diff / err; if (r1 >= 10.0f && diff >= 1.0f) { fprintf(logfile, "\n *E* Gamma does not fit between levels, deviation= %.0f sigma\n" " Levels:%10.3f and %10.3f. Eg=%10.3f DeltaE=%10.3f\n" " %10.3f %10.3f. %10.3f %10.3f\n" " Previous/next final level: %.3f %.3f and %.3f %.3f\n", r1, ein, efi, eg, dl, dein, defi, deg, ddl, elo, delo, ehi, dehi); } return 0; } /* chgam */ int chmult(int j1, char par1, char jpimod1, int j2, char par2, char jpimod2, int *ml, char *mlpar, char *mult, double eg, double el1, double el2, float d, float dd, float dd2, double elo, double delo, double ehi, double dehi) { int jsum, jdiff, okpar, ok1, ok2; char dpar, jpi1[16], jpi2[16]; /* Make sure that gamma multipolarity is consistent with level spins Arguments: Spin, parity, modstring of initial level Spin, parity, modstring of final level Multipolarities, parity, modstring of gamma ENSDF mult string Both muliporarities inconsistent with JPi's: *E* One muliporarity inconsistent with JPi's: *W* gd.iodd = 2 for odd A, or 1 for even A */ /* Check for given mixing ratio and no second multipole */ if ((d != 0.f || dd != 0.f) && ml[1] < 0) { putjpi(jpi1, j1, par1, jpimod1); putjpi(jpi2, j2, par2, jpimod2); fprintf(logfile, "\n *E* Non-zero mixing ratio and no second multipole: %s\n" " Mixing ratio %.2f +%.2f -%.2f\n" " Eg= %.3f from level %.3f to level %.3f\n" " Level spin/parities: %s and %s\n", mult, d, dd, dd2, eg, el1, el2, jpi1, jpi2); } if (ml[0] < 0 && *mlpar == ' ') return 0; if (j1 < 0 && par1 == ' ') return 0; if (j2 < 0 && par2 == ' ') return 0; /* Calculate Spin difference and parity change */ jdiff = abs(j1 - j2); jsum = j1 + j2; /* No spin check if any of the levels has unknown spin */ if (j1 == -1 || j2 == -1) { jdiff = 0; jsum = 199; } dpar = ' '; if ((par1 == '+' && par2 == '+' ) || (par1 == '-' && par2 == '-' )) dpar = '+'; if ((par1 == '-' && par2 == '+' ) || (par1 == '+' && par2 == '-' )) dpar = '-'; okpar = 1; ok1 = 1; ok2 = 1; /* Compare with multipolarity */ /* Parity: */ if (dpar != ' ' && dpar != *mlpar && *mlpar != ' ') okpar = 0; /* Spins: */ if (ml[0] * gd.iodd < jdiff || ml[0] * gd.iodd > jsum) ok1 = 0; if (ml[1] > 0 && (ml[1] * gd.iodd < jdiff || ml[1] * gd.iodd > jsum)) ok2 = 0; if (!okpar || (!ok1 && !ok2)) { putjpi(jpi1, j1, par1, jpimod1); putjpi(jpi2, j2, par2, jpimod2); fprintf(logfile, "\n *E* Multipolarity inconsistent with spin/parities: %s\n" " Eg= %.3f from level %.3f to level %.3f\n" " Level spin/parities: %s and %s\n" " Previous/next final level: %.3f %.3f and %.3f %.3f\n", mult, eg, el1, el2, jpi1, jpi2, elo, delo, ehi, dehi); } return 0; } /* chmult */ int match(double x, double *y, int i) { double ds = 1e10, dx; int ret_val = 0, m; /* Finds closest match of X to array Y(I) */ for (m = 0; m < i; ++m) { dx = fabs(x - y[m]); if (dx - ds > 25.f) break; if (dx <= ds) { ds = dx; ret_val = m + 1; } } return ret_val; } /* match */ /*#############################################################*/ /* wags */ /* ======================================================================= */ int wags(void) { /* Initialized data */ static char *band_suffix = "&+o &+e &+? &-o &-e &-? &?o &?e &??"; static char *msgA = "\n*** NOTE THAT SOME ENSDF ASSIGNMENTS ARE NOT PRESERVED ***\n\n" "PLEASE NOTE that RadWare-format files cannot preserve,\n" " in any strict sense, the careful data assignments made by\n" " nuclear data evaluators and stored in the ENSDF files.\n" " The RadWare format is much more limited than the ENSDF one;\n" " for example, in RadWare, transition multipolarities are\n" " deduced from the level spins and parities, while in ENSDF a\n" " transition may have no multipolarity assigned, or one assigned\n" " in a range of different ways. Other quantities required by\n" " the RadWare format may or may not be assigned in the ENSDF\n" " file, and some quantities in ENSDF (lifetimes, for example)\n" " do not have any RadWare-format equivalent. For this reason,\n" " DO NOT assume that this file gives a true representation of\n" " the assignments made (or not made) in ENSDF!\n\n" "ENSDF Gamma intensities have been renormalized.\n\n"; static char *msgB = "For this nucleus, a blank level spin label indicates\n" " that in ENSDF either none or multiple JPI was assigned.\n"; static char *msgC = "For this nucleus, a level spin label of -1/2 indicates\n" " that in ENSDF either none or multiple JPI was assigned.\n"; float r, delsq, ad, band_k, deltae, deltas, ddeltae, convt[8]; int i1, i2, step, level_lookup[MAXLEV], i, j, jband, il; int junk_band[9], itent, count, j1, j2, jj, jk, ideltas; char ch, buf[512], jpi[8], kay[8], multipol[8], intens[24], dattim[20]; /* Writes AGS file using common block data */ datetime(dattim); /* Write file history */ fprintf(agsfile, "** NUCID = %s A = %3d Z = %3d N = %3d\n" "** %s" "** ASCII Graphical Level Scheme file (Radware)\n" "** Created from ENSDF with %s on %s\n" "** ** NOTE THAT SOME ENSDF ASSIGNMENTS ARE NOT PRESERVED" " - see .txt file **\n" " ASCII GLS file format version 1.0\n", gd.nucid, gd.a, gd.z, gd.a - gd.z, gd.dsid, VERSION, dattim); fprintf(txtfile, "** NUCID = %s A = %3d Z = %3d N = %3d\n" "** %s" "** ASCII Graphical Level Scheme file (Radware)\n" "** Created from ENSDF with %s\n" "** This file was created %s\n", gd.nucid, gd.a, gd.z, gd.a - gd.z, gd.dsid, VERSION, dattim); fprintf(txtfile, msgA); if (gd.iodd == 1) { fprintf(txtfile, msgB); } else { fprintf(txtfile, msgC); } fprintf(txtfile, "\n* Band labels:\n" " 150Ce+BO\n" " ^ O/E for odd/even spins\n" " ^ Band label from ENSDF\n" " ^ Parity\n" " ^^^^^ Nuclide\n" " 150Ce&+o\n" " ^ indicates levels not assigned to bands by ENSDF\n" " ^ Parity (? = unknown parity)\n" " ^ o/e/? for odd/even/unknown spins\n\n"); /* find out band properties */ bdprop(); /* initial gls values (most are just defaults) */ glsgd.atomic_no = gd.z; glsgd.nbands = glsgd.nlevels = glsgd.ntlabels = 0; glsgd.ngammas = gd.ngam; glsgd.csx = glsgd.lsl_csx = glsgd.lel_csx = glsgd.gel_csx = 75.0f; glsgd.csy = glsgd.lsl_csy = glsgd.lel_csy = glsgd.gel_csy = 85.0f; glsgd.aspect_ratio = 3.0f; glsgd.max_tangent = 0.2679f; glsgd.max_dist = 999.0f; glsgd.arrow_width = 40.0f; glsgd.arrow_length = 80.0f; glsgd.default_width = 600.0f; glsgd.default_sep = 150.0f; glsgd.arrow_break = 30.0f; glsgd.level_break = 40.0f; for (i = 0; i < MAXGAM; ++i) { glsgd.gam[i].e = glsgd.gam[i].de = 0.0f; glsgd.gam[i].i = 10.f; glsgd.gam[i].di = 0.0f; glsgd.gam[i].br = glsgd.gam[i].a = glsgd.gam[i].d = 0.0f; glsgd.gam[i].dbr = glsgd.gam[i].da = glsgd.gam[i].dd = 0.0f; glsgd.gam[i].x1 = glsgd.gam[i].x2 = 0.0f; glsgd.gam[i].eldx = glsgd.gam[i].eldy = 0.0f; glsgd.gam[i].flg = glsgd.gam[i].elflg = 0; } for (i = 0; i < MAXLEV; ++i) { glsgd.lev[i].e = glsgd.lev[i].de = glsgd.lev[i].j = 0.0f; glsgd.lev[i].pi = 1.0f; glsgd.lev[i].k = 0.0f; glsgd.lev[i].dxl = glsgd.lev[i].dxr = 0.0f; glsgd.lev[i].sldx = glsgd.lev[i].sldy = 0.0f; glsgd.lev[i].eldx = glsgd.lev[i].eldy = 0.0f; glsgd.lev[i].flg = glsgd.lev[i].slflg = glsgd.lev[i].elflg = 0; } for (i = 0; i < MAXBAND; ++i) { glsgd.bnd[i].x0 = (glsgd.default_width + glsgd.default_sep) * (float) (40 + i); glsgd.bnd[i].nx = glsgd.default_width; glsgd.bnd[i].sldx = glsgd.bnd[i].sldy = 0.0f; glsgd.bnd[i].eldx = glsgd.bnd[i].eldy = 0.0f; strncpy(glsgd.bnd[i].name, " ", 8); } /* Is data set ADOPTED LEVELS (for intensity renormalization)? */ ad = 0.1f; /* ----bands--- */ printf("NBAND, NLev, NGam: %d %d %d\n", gd.nband, gd.nlev, gd.ngam); fprintf(txtfile, "NBAND, NLev, NGam in ENSDF file: %d %d %d\n", gd.nband, gd.nlev, gd.ngam); for (j = 0; j < gd.nband; ++j) { glsgd.nbands++; count = 0; fprintf(txtfile, "* BAND(%c) %s\n", gd.bd[j], gd.bandid[j]); strcpy(kay, " ?"); if (gd.iodd == 1) { step = gd.bdstep[j]; band_k = (float) gd.bdk[j]; if (band_k >= 0.f) sprintf(kay, "%6d", gd.bdk[j]); } else { step = gd.bdstep[j] / 2; band_k = ((float) gd.bdk[j]) / 2.0f; if (band_k >= 0.f) sprintf(kay, "%4d/2", gd.bdk[j]); } fprintf(txtfile, "* Band properties: %s K:%s%c step:%2d\n", gd.bdstr[j], kay, gd.bdpi[j], gd.bdstep[j]); if (step == 1) ++glsgd.nbands; /* Print level data for band levels */ for (i = 0; i < gd.nlev; ++i) { if (gd.ban[i] == gd.bd[j]) { level_lookup[i] = il = glsgd.nlevels++; label(i, j, count, gd.levlab[i]); ++count; if (gd.joffs[i] == ' ') { r = ((float) gd.spin[i]) / (float) gd.iodd; } else { /* Spin is integer. Add spin offset if present */ r = (float) gd.spin[i] + ((float) gd.ioffs[j]) / (float) gd.iodd; } /* check for integer / half-integer spin for even / odd nuclei */ if (gd.iodd == 1) { if (fabs(r - (float) rint(r)) > .2f) { sprintf(buf, " * ERROR - level %s at %.2f keV has half-integer spin!\n" " - changing spin from %.1f to %.1f\n", gd.levlab[i], gd.el[i], r, r - 0.5f); printf(buf); fprintf(logfile, buf); fprintf(txtfile, buf); r -= 0.5f; } } else if (fabs(r - (float) rint(r)) < .2f) { sprintf(buf, " * ERROR - level %s at %.2f keV has integer spin!\n" " - changing spin from %.1f to %.1f\n", gd.levlab[i], gd.el[i], r, r - 0.5f); printf(buf); fprintf(logfile, buf); fprintf(txtfile, buf); r -= 0.5f; } if (step == 1 && ((int) (r + 0.2f)) % 2 == 0) { jband = glsgd.nbands - 2; } else { jband = glsgd.nbands - 1; } itent = levstat(gd.unclev[i], gd.spin[i], gd.parity[i], gd.jpimod[i], gd.joffs[i]); if (!strncmp(glsgd.bnd[jband].name, " ", 8)) strncpy(glsgd.bnd[jband].name, gd.levlab[i], 8); glsgd.lev[il].e = gd.el[i]; glsgd.lev[il].de = gd.del[i]; glsgd.lev[il].j = r; glsgd.lev[il].pi = 1.0f; if (gd.parity[i] == '-') glsgd.lev[il].pi = -1.0f; if (gd.parity[i] == ' ') glsgd.lev[il].pi = 0.0f; glsgd.lev[il].k = band_k; glsgd.lev[il].band = jband; glsgd.lev[il].slflg = itent; if (gd.unclev[i] != ' ') glsgd.lev[il].flg = 1; } } } /* ---levels without band assignment--- */ label(0, 0, 0, gd.levlab[0]); for (i = 0; i < 9; ++i) { strncpy(glsgd.bnd[glsgd.nbands].name, gd.levlab[0], 5); strncpy(glsgd.bnd[glsgd.nbands].name + 5, band_suffix + i*4, 3); junk_band[i] = 1; ++glsgd.nbands; } for (i = 0; i < gd.nlev; ++i) { if (gd.ban[i] == ' ') { level_lookup[i] = il = glsgd.nlevels++; label(i, 0, 0, gd.levlab[i]); itent = levstat(gd.unclev[i], gd.spin[i], gd.parity[i], gd.jpimod[i], gd.joffs[i]); r = ((float) gd.spin[i]) / (float) gd.iodd; /* check for integer / half-integer spin for even / odd nuclei */ if (gd.iodd == 1) { if (fabs(r - (float) rint(r)) > .2f) { sprintf(buf, " * ERROR - level %s at %.2f keV has half-integer spin!\n" " - changing spin from %.1f to %.1f\n", gd.levlab[i], gd.el[i], r, r - 0.5f); printf(buf); fprintf(logfile, buf); fprintf(txtfile, buf); r -= 0.5f; } } else if (fabs(r - (float) rint(r)) < .2f) { sprintf(buf, " * ERROR - level %s at %.2f keV has integer spin!\n" " - changing spin from %.1f to %.1f\n", gd.levlab[i], gd.el[i], r, r - 0.5f); printf(buf); fprintf(logfile, buf); fprintf(txtfile, buf); r -= 0.5f; } glsgd.lev[il].e = gd.el[i]; glsgd.lev[il].de = gd.del[i]; glsgd.lev[il].j = r; glsgd.lev[il].pi = 1.0f; if (gd.parity[i] == '-') glsgd.lev[il].pi = -1.0f; if (gd.parity[i] == ' ') glsgd.lev[il].pi = 0.0f; if (gd.parity[i] == '+') { jband = 0; } else if (gd.parity[i] == '-') { jband = 3; } else { jband = 6; } if (itent > 5) { jband += 2; } else if ((int) (glsgd.lev[il].j + 0.2f) % 2 == 0) { ++jband; } junk_band[jband] = 0; glsgd.lev[il].band = glsgd.nbands + jband - 9; glsgd.lev[il].slflg = itent; if (gd.unclev[i] != ' ') glsgd.lev[il].flg = 1; } } jband = glsgd.nbands; for (i = 8; i >= 0; --i) { --jband; if (junk_band[i]) { --glsgd.nbands; for (j = jband; j <= glsgd.nbands; ++j) { strncpy(glsgd.bnd[j].name, glsgd.bnd[j + 1].name, 8); } for (j = 0; j < glsgd.nlevels; ++j) { if (glsgd.lev[j].band > jband) --glsgd.lev[j].band; } } } /* ----gammas--- */ if (gd.ngam > MAXGAM) { sprintf(buf, " * ERROR - too many gammas for .ags: %d\n" " - taking only the first %d\n", gd.ngam, MAXGAM); printf(buf); fprintf(logfile, buf); fprintf(txtfile, buf); } jk = 0; i1 = (gd.ngam < MAXGAM ? gd.ngam : MAXGAM); for (jj = 0; jj < i1; ++jj) { glsgd.gam[jk].e = gd.egam[jj]; glsgd.gam[jk].de = gd.degam[jj]; if (gd.degam[jj] < .3f && gd.degam[jj] > 0.f) glsgd.gam[jk].elflg = 3; glsgd.gam[jk].i = gd.igam[jj] * ad; glsgd.gam[jk].di = gd.digam[jj] * ad; if (gd.d[jj] != 0.f || gd.dd[jj] > 0.f) { glsgd.gam[jk].d = gd.d[jj]; glsgd.gam[jk].dd = (gd.dd[jj] > gd.dd2[jj] ? gd.dd[jj] : gd.dd2[jj]); } glsgd.gam[jk].li = level_lookup[gd.inlev[jj]]; glsgd.gam[jk].lf = level_lookup[gd.finlev[jj]]; if (gd.unctr[jj] != ' ') { glsgd.gam[jk].flg = 1; ++glsgd.gam[jk].elflg; } /* add branching ratio information if data set is adopted levels and gammas... */ if (strstr(gd.dsid, "ADOPTED") && strstr(gd.dsid, "LEVELS")) { glsgd.gam[jk].br = gd.igam[jj]; glsgd.gam[jk].dbr = gd.digam[jj]; } deltas = glsgd.lev[glsgd.gam[jk].li].j - glsgd.lev[glsgd.gam[jk].lf].j; ideltas = rint(deltas); if (fabs(deltas - (float) ideltas) > .1f) { sprintf(buf, " * ERROR - one level has half-integer spin\n" " other level has integer spin, for gamma:%10.3f\n" " from %s %.1f to %s %.1f\n", glsgd.gam[jk].e, glsgd.bnd[glsgd.lev[glsgd.gam[jk].li].band].name, glsgd.lev[glsgd.gam[jk].li].j, glsgd.bnd[glsgd.lev[glsgd.gam[jk].lf].band].name, glsgd.lev[glsgd.gam[jk].lf].j); printf(buf); fprintf(logfile, buf); fprintf(txtfile, buf); } ideltas = abs(ideltas); if (ideltas > 9) ideltas = 9; if (glsgd.lev[glsgd.gam[jk].li].pi * glsgd.lev[glsgd.gam[jk].lf].pi > 0.f) { if (ideltas % 2 == 0) { ch = 'E'; } else { ch = 'M'; } } else { if (ideltas % 2 == 0) { ch = 'M'; } else { ch = 'E'; } } if (ideltas == 0) { ideltas = 1; if (ch == 'M') { ch = 'E'; } else { ch = 'M'; } } if (glsgd.lev[glsgd.gam[jk].li].slflg > 4 || glsgd.lev[glsgd.gam[jk].lf].slflg > 4) { ch = ' '; ideltas = 0; } glsgd.gam[jk].em = ch; glsgd.gam[jk].n = (float) ideltas; /* check energy of gamma against level energy difference */ deltae = glsgd.lev[glsgd.gam[jk].li].e - glsgd.lev[glsgd.gam[jk].lf].e; ddeltae = sqrt(glsgd.lev[glsgd.gam[jk].li].de * glsgd.lev[glsgd.gam[jk].li].de + glsgd.lev[glsgd.gam[jk].lf].de * glsgd.lev[glsgd.gam[jk].lf].de + glsgd.gam[jk].de * glsgd.gam[jk].de); if (ddeltae <= .001f) ddeltae = 1.f; if (fabs(deltae - glsgd.gam[jk].e) > ddeltae * 4.f && fabs(deltae - glsgd.gam[jk].e) > 3.f) { sprintf(buf, " * ERROR - gamma energy does not match difference in\n" " level energies (err =%10.3f) for gamma:%10.3f\n" " from %s %.1f to %s %.1f\n", fabs(deltae - glsgd.gam[jk].e), glsgd.gam[jk].e, glsgd.bnd[glsgd.lev[glsgd.gam[jk].li].band].name, glsgd.lev[glsgd.gam[jk].li].j, glsgd.bnd[glsgd.lev[glsgd.gam[jk].lf].band].name, glsgd.lev[glsgd.gam[jk].lf].j); printf(buf); fprintf(logfile, buf); fprintf(txtfile, buf); } /* if gamma energy too small, delete gamma..... */ if (glsgd.gam[jk].e < 1.f) { sprintf(buf, " **** Deleting gamma of energy%10.3f\n" " from %s %.1f to %s %.1f\n", glsgd.gam[jk].e, glsgd.bnd[glsgd.lev[glsgd.gam[jk].li].band].name, glsgd.lev[glsgd.gam[jk].li].j, glsgd.bnd[glsgd.lev[glsgd.gam[jk].lf].band].name, glsgd.lev[glsgd.gam[jk].lf].j); printf(buf); fprintf(logfile, buf); fprintf(txtfile, buf); --jk; } ++jk; } glsgd.ngammas = jk; bandcheck(); /* calculate conversion coeffients */ for (i = 0; i < glsgd.ngammas; ++i) { if (glsgd.gam[i].a == 0.f) { hsicc(glsgd.atomic_no, &glsgd.gam[i].e, 1, convt); if (glsgd.gam[i].em == 'E') { j1 = (int) (0.5f + glsgd.gam[i].n) - 1; j2 = j1 + 5; if (j1 > 3) j1 = 0; if (j2 > 7) j2 = 5; } else { j1 = (int) (0.5f + glsgd.gam[i].n) + 3; j2 = j1 - 3; if (j1 > 7) j1 = 4; if (j2 > 3) j2 = 1; } if (glsgd.gam[i].d != 0.f) { delsq = glsgd.gam[i].d * glsgd.gam[i].d; glsgd.gam[i].a = (convt[j1] + delsq * convt[j2]) / (delsq + 1.0f); } else { glsgd.gam[i].a = convt[j1]; } if (glsgd.gam[i].em == ' ') glsgd.gam[i].a = 0.f; } if ((r = glsgd.gam[i].i * (glsgd.gam[i].a + 1.0f)) > 150.f) { /* fix intensities of all gammas out of intial level so max total intensity is 150 */ r /= 150.f; for (j = 0; j < glsgd.ngammas; ++j) { if (glsgd.gam[j].li == glsgd.gam[i].li) { fprintf(txtfile, " * Reduced intensity of gamma%10.3f\n" " from %8.2f to %8.2f\n", glsgd.gam[j].e, glsgd.gam[j].i, glsgd.gam[j].i / r); glsgd.gam[j].i /= r; glsgd.gam[j].di /= r; } } } } /* ---from libs/gls/read_write_gls.f---- */ /* --- except file replaced by agsfile and other changes flagged by dcr ---- */ /* write everything out */ fprintf(agsfile, "** Z Nlevels Ngammas Nbands Nlabels CharSizeX CharSizeY ArrowWidFact\n" "%5i %7i %7i %7i %7i %9.2f %9.2f %9.2f\n" "** MaxArrowTan MaxArrowDX DefBandWid DefBandSep ArrowWidth ArrowLength\n" "%15.6f %10.2f %10.2f %10.2f %10.2f %10.2f\n" "** ArrowBreak LevelBreak LevCSX LevCSY LevEnCSX LevEnCSY GamCSX GamCSY\n" "%12.2f %11.2f %8.2f %8.2f %8.2f %8.2f %8.2f %8.2f\n" "** Level Energy +/- err Jpi K Band# LevelFlag LabelFlag EnLabFlag\n" "++ LabelDX LabelDY EnLabelDX EnLabelDY LevelDX1 LevelDX2\n", glsgd.atomic_no, glsgd.nlevels, glsgd.ngammas, glsgd.nbands, glsgd.ntlabels, glsgd.csx, glsgd.csy, glsgd.aspect_ratio, glsgd.max_tangent, glsgd.max_dist, glsgd.default_width, glsgd.default_sep, glsgd.arrow_width, glsgd.arrow_length, glsgd.arrow_break, glsgd.level_break, glsgd.lsl_csx, glsgd.lsl_csy, glsgd.lel_csx, glsgd.lel_csy, glsgd.gel_csx, glsgd.gel_csy); for (j = 0; j < glsgd.nlevels; ++j) { j2 = (int)(glsgd.lev[j].j * 2.f + 0.5f); if (glsgd.lev[j].j < 0.0f) j2 = (int)(glsgd.lev[j].j * 2.f - 0.5f); j1 = j2 / 2; /* dcr 98/10/14 remove J assignment for unknown spins in even nuclei */ /* if (j2 == j1 << 1) { */ if (glsgd.lev[j].j < -0.7f) { strcpy(jpi, " "); } else if (j2 == j1 << 1) { /* ---- */ sprintf(jpi, "%7i", j1); } else { sprintf(jpi, "%5i/2", j2); } if (glsgd.lev[j].pi < 0.f) { jpi[7] = '-'; /* dcr 98/10/14 remove parity assignment for unknown parities */ } else if (glsgd.lev[j].pi == 0.f) { jpi[7] = ' '; /* ---- */ } else { jpi[7] = '+'; } j2 = (int)(glsgd.lev[j].k * 2.f + 0.5f); j1 = j2 / 2; /* dcr 98/10/14 */ /* if (j2 == j1 << 1) { */ if (glsgd.lev[j].k < -0.2f) { strcpy(kay, " "); } else if (j2 == j1 << 1) { /* ---- */ sprintf(kay, "%6i", j1); } else { sprintf(kay, "%4i/2", j2); } fprintf(agsfile, "%6i %10.3f %7.3f%.8s%.6s %5i %9i %9i %9i &\n" "++ %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f\n", j+1, glsgd.lev[j].e, glsgd.lev[j].de, jpi, kay, glsgd.lev[j].band+1, glsgd.lev[j].flg, glsgd.lev[j].slflg, glsgd.lev[j].elflg, glsgd.lev[j].sldx, glsgd.lev[j].sldy, glsgd.lev[j].eldx, glsgd.lev[j].eldy, glsgd.lev[j].dxl, glsgd.lev[j].dxr); } fprintf(agsfile, "** Band Name X0 NX LabelDX LabelDY EnLabelDX EnLabelDY\n"); for (j = 0; j < glsgd.nbands; ++j) { fprintf(agsfile, "%5i %.8s %9.2f %9.2f %9.2f %9.2f %9.2f %9.2f\n", j+1, glsgd.bnd[j].name, glsgd.bnd[j].x0, glsgd.bnd[j].nx, glsgd.bnd[j].sldx, glsgd.bnd[j].sldy, glsgd.bnd[j].eldx, glsgd.bnd[j].eldy); } fprintf(agsfile, "** Gamma Energy +/- err Mult ILev FLev Intensity +/- err\n" "++ ConvCoef +/- error BrRatio +/- error MixRatio +/- error\n" "++ GammaX1 GammaX2 LabelDX LabelDY GammaFlag LabelFlag\n"); for (j = 0; j < glsgd.ngammas; ++j) { i2 = (int) (glsgd.gam[j].n + 0.5f); /* dcr suppress multipolarity if i2 == 0 */ if (glsgd.gam[j].em == ' ') { strcpy(multipol, " "); } else { sprintf(multipol, "%c%2i", glsgd.gam[j].em, i2); } /* dcr suppress intensity if == 0 */ sprintf(intens, "%10.4f %7.4f", glsgd.gam[j].i, glsgd.gam[j].di); if (glsgd.gam[j].i <= 0.0f) memset(intens, ' ', 10); if (glsgd.gam[j].di <= 0.0f) memset(intens + 11, ' ', 7); fprintf(agsfile, "%6i %10.3f %7.3f %s %5i %5i %s &\n" "++ %12.5E %9.3E %12.5E %9.3E %12.5E %9.3E &\n" "++ %9.2f %9.2f %9.2f %9.2f %9i %9i\n", j+1, glsgd.gam[j].e, glsgd.gam[j].de, multipol, glsgd.gam[j].li+1, glsgd.gam[j].lf+1, intens, glsgd.gam[j].a, glsgd.gam[j].da, glsgd.gam[j].br, glsgd.gam[j].dbr, glsgd.gam[j].d, glsgd.gam[j].dd, glsgd.gam[j].x1, glsgd.gam[j].x2, glsgd.gam[j].eldx, glsgd.gam[j].eldy, glsgd.gam[j].flg, glsgd.gam[j].elflg); /* ---- */ } fprintf(agsfile, "** Label text NChars\n" "++ SizeX SizeY PositionX PositionY\n"); for (j = 0; j < glsgd.ntlabels; ++j) { fprintf(agsfile, "%5i %-40.40s %7i &\n" "++ %9.2f %9.2f %9.2f %9.2f\n", j+1, glsgd.txt[j].l, glsgd.txt[j].nc, glsgd.txt[j].csx, glsgd.txt[j].csy, glsgd.txt[j].x, glsgd.txt[j].y); } /* dcr add level energy modification info (+X etc) */ fprintf(agsfile,"\n*** Level energy offset flags/modifiers:\n" "*** Level Band(level) EnergyModifier\n"); for (j = 0; j < glsgd.nlevels; ++j) { jj = level_lookup[j]; if (gd.mel[jj] != ' ') fprintf(agsfile,"%9d %s +%c\n", j+1, glsgd.bnd[glsgd.lev[j].band].name, gd.mel[jj]); } /* ---- */ fprintf(txtfile, "NBANDS, NLevels, NGammas in .ags file: %d %d %d\n", glsgd.nbands, glsgd.nlevels, glsgd.ngammas); fprintf(agsfile, msgA); if (gd.iodd == 1) { fprintf(agsfile, msgB); } else { fprintf(agsfile, msgC); } return 0; } /* wags */