00001
00002
00003
00004
00005
00006 #include "cddefines.h"
00007 #include "input.h"
00008 #include "conv.h"
00009 #include "optimize.h"
00010 #include "iso.h"
00011 #include "called.h"
00012 #include "map.h"
00013 #include "thermal.h"
00014 #include "pressure.h"
00015 #include "struc.h"
00016 #include "wind.h"
00017 #include "h2.h"
00018 #include "colden.h"
00019 #include "dense.h"
00020 #include "lines.h"
00021 #include "secondaries.h"
00022 #include "radius.h"
00023 #include "version.h"
00024 #include "hmi.h"
00025 #include "prt.h"
00026 #include "grainvar.h"
00027 #include "atomfeii.h"
00028 #include "cddrive.h"
00029 #include "elementnames.h"
00030 #include "assertresults.h"
00031 #include "taulines.h"
00032 #include "lines_service.h"
00033
00034
00035 static bool lgInitDone=false ,
00036
00037 lgSpaceAllocated=false;
00038
00039
00040 #define NASSERTS 100
00041
00042
00043 #define DEF_ERROR 0.05
00044
00045
00046 #define NCHAR 5
00047 static char **chAssertLineLabel;
00048
00049
00050 static char *chAssertLimit;
00051
00052
00053 static char **chAssertType;
00054
00055
00056 static double *AssertQuantity ,*AssertQuantity2 ,*AssertError, **Param;
00057
00058
00059 static int *lgQuantityLog;
00060 static long nAsserts=0;
00061 static float *wavelength;
00062
00063
00064
00065 void InitAssertResults(void)
00066 {
00067
00068
00069
00070 lgInitDone = true;
00071 nAsserts = 0;
00072 }
00073
00074
00075
00076 void ParseAssertResults(void)
00077 {
00078 long i ,
00079 nelem,
00080 n2;
00081 bool lgEOL;
00082 char chLabel[INPUT_LINE_LENGTH];
00083
00084 if( !lgInitDone )
00085 {
00086 fprintf( ioQQQ, " ParseAssertResults called before InitAsserResults\n" );
00087 puts( "[Stop in ParseAssertResults]" );
00088 cdEXIT(EXIT_FAILURE);
00089 }
00090
00091 DEBUG_ENTRY( "ParseAssertResults()" );
00092
00093
00094 if( !lgSpaceAllocated )
00095 {
00096
00097
00098 lgSpaceAllocated = true;
00099
00100
00101 chAssertLineLabel = ((char **)MALLOC(NASSERTS*sizeof(char *)));
00102
00103
00104 chAssertType = ((char **)MALLOC(NASSERTS*sizeof(char *)));
00105
00106
00107 Param = ((double **)MALLOC(NASSERTS*sizeof(double * )));
00108
00109
00110 for( i=0; i<NASSERTS; ++i )
00111 {
00112 chAssertLineLabel[i] = ((char *)MALLOC(NCHAR*sizeof(char )));
00113 strcpy(chAssertLineLabel[i],"unkn" );
00114
00115
00116 chAssertType[i] = ((char *)MALLOC(3*sizeof(char )));
00117 strcpy(chAssertType[i],"un" );
00118
00119
00120 Param[i] = ((double *)MALLOC(NASSERTS*sizeof(double )));
00121 }
00122
00123
00124 AssertQuantity = ((double *)MALLOC(NASSERTS*sizeof(double )));
00125
00126 AssertQuantity2 = ((double *)MALLOC(NASSERTS*sizeof(double )));
00127
00128
00129 AssertError = ((double *)MALLOC(NASSERTS*sizeof(double )));
00130
00131
00132 wavelength = ((float *)MALLOC(NASSERTS*sizeof(float )));
00133
00134
00135 lgQuantityLog = ((int *)MALLOC(NASSERTS*sizeof(int )));
00136
00137
00138 chAssertLimit = ((char *)MALLOC(NASSERTS*sizeof(char )));
00139 }
00140
00141
00142
00143 strcpy( chAssertType[nAsserts] , "un" );
00144
00145
00146
00147 lgQuantityLog[nAsserts] = false;
00148
00149
00150 if( nMatch("<",input.chCARDCAPS ) )
00151 {
00152 chAssertLimit[nAsserts] = '<';
00153 }
00154 else if( nMatch(">",input.chCARDCAPS ) )
00155 {
00156 chAssertLimit[nAsserts] = '>';
00157 }
00158 else
00159 {
00160 chAssertLimit[nAsserts] = '=';
00161 }
00162
00163
00164
00165
00166 if( nMatch("IONI",input.chCARDCAPS ) )
00167 {
00168
00169
00170
00171
00172
00173
00174 if( nMatch("VOLU",input.chCARDCAPS ) )
00175 {
00176 strcpy( chAssertType[nAsserts] , "F " );
00177 }
00178 else
00179 {
00180
00181 strcpy( chAssertType[nAsserts] , "f " );
00182 }
00183
00184
00185 if( (nelem = GetElem(input.chCARDCAPS)) < 0 )
00186 {
00187 fprintf( ioQQQ,
00188 " I could not identify an element name on this line.\n");
00189 fprintf( ioQQQ, " Sorry.\n" );
00190 puts( "[Stop in ParseAssertResults]" );
00191 cdEXIT(EXIT_FAILURE);
00192 }
00193 ASSERT( nelem>= 0);
00194 ASSERT( nAsserts>= 0);
00195
00196
00197 strcpy( chAssertLineLabel[nAsserts], elementnames.chElementNameShort[nelem] );
00198
00199
00200 i = 5;
00201 wavelength[nAsserts] =
00202 (float)FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00203 if( lgEOL )
00204 {
00205 NoNumb(input.chOrgCard);
00206 }
00207
00208 if( wavelength[nAsserts] < 1 || wavelength[nAsserts] > nelem+2 )
00209 {
00210 fprintf( ioQQQ,
00211 " The ionization stage is inappropriate for this element.\n");
00212 fprintf( ioQQQ, " Sorry.\n" );
00213 puts( "[Stop in ParseAssertResults]" );
00214 cdEXIT(EXIT_FAILURE);
00215 }
00216
00217
00218
00219 AssertQuantity[nAsserts] =
00220 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00221 if( lgEOL )
00222 {
00223 NoNumb(input.chOrgCard);
00224 }
00225
00226
00227
00228 if( AssertQuantity[nAsserts] <= 0. )
00229 {
00230
00231 AssertQuantity[nAsserts] =
00232 pow(10.,AssertQuantity[nAsserts] );
00233
00234 lgQuantityLog[nAsserts] = true;
00235 }
00236 else if( AssertQuantity[nAsserts] > 1. )
00237 {
00238 fprintf( ioQQQ,
00239 " The ionization fraction must be less than one.\n");
00240 fprintf( ioQQQ, " Sorry.\n" );
00241 puts( "[Stop in ParseAssertResults]" );
00242 cdEXIT(EXIT_FAILURE);
00243 }
00244
00245
00246 if( fabs(AssertQuantity[nAsserts]) <= SMALLDOUBLE )
00247 {
00248 fprintf( ioQQQ,
00249 " The ionization ionization fraction is too small, or zero. Check input\n");
00250 fprintf( ioQQQ, " Sorry.\n" );
00251 puts( "[Stop in ParseAssertResults]" );
00252 cdEXIT(EXIT_FAILURE);
00253 }
00254
00255
00256
00257 AssertError[nAsserts] =
00258 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00259 if( lgEOL )
00260 {
00261
00262 AssertError[nAsserts] = DEF_ERROR;
00263 }
00264 }
00265
00266
00267 else if( nMatch("MOLE",input.chCARDCAPS )&&nMatch("FRAC",input.chCARDCAPS ) )
00268 {
00269
00270
00271
00272
00273
00274
00276 if( nMatch("VOLU",input.chCARDCAPS ) )
00277 {
00278 strcpy( chAssertType[nAsserts] , "MF" );
00279 }
00280 else
00281 {
00282
00283 strcpy( chAssertType[nAsserts] , "mf" );
00284 }
00285
00286 i = nMatch(" H2 ",input.chCARDCAPS );
00287 if( i )
00288 {
00289 strcpy( chAssertLineLabel[nAsserts], "H2 " );
00290
00291 i += 3;
00292 }
00293 else if( nMatch(" CO ",input.chCARDCAPS ) )
00294 {
00295 strcpy( chAssertLineLabel[nAsserts], "CO " );
00296 i = 5;
00297 }
00298 else
00299 {
00300 fprintf( ioQQQ,
00301 " I could not identify CO or H2 on this line.\n");
00302 fprintf( ioQQQ, " Sorry.\n" );
00303 puts( "[Stop in ParseAssertResults]" );
00304 cdEXIT(EXIT_FAILURE);
00305 }
00306
00307
00308 wavelength[nAsserts] = 0;
00309
00310
00311
00312 AssertQuantity[nAsserts] =
00313 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00314 if( lgEOL )
00315 {
00316 NoNumb(input.chOrgCard);
00317 }
00318 if( AssertQuantity[nAsserts] <= 0. )
00319 {
00320
00321 AssertQuantity[nAsserts] =
00322 pow(10.,AssertQuantity[nAsserts] );
00323 }
00324
00325
00326
00327 AssertError[nAsserts] =
00328 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00329 if( lgEOL )
00330 {
00331
00332 AssertError[nAsserts] = DEF_ERROR;
00333 }
00334
00335 lgQuantityLog[nAsserts] = true;
00336 }
00337
00338
00339 else if( nMatch("INE ",input.chCARDCAPS ) )
00340 {
00341 if( nMatch("LUMI",input.chCARDCAPS ) || nMatch("INTE",input.chCARDCAPS ))
00342 {
00343
00344 strcpy( chAssertType[nAsserts] , "Ll" );
00345
00346
00347 lgQuantityLog[nAsserts] = true;
00348 }
00349 else
00350 {
00351
00352 strcpy( chAssertType[nAsserts] , "Lr" );
00353
00354
00355 lgQuantityLog[nAsserts] = false;
00356 }
00357
00358
00359
00360 GetQuote( chLabel , input.chCARDCAPS , true );
00361
00362
00363 if( chLabel[4] != '\0' )
00364 {
00365 fprintf( ioQQQ,
00366 " The label must be exactly 4 char long, between double quotes.\n");
00367 fprintf( ioQQQ, " Sorry.\n" );
00368 puts( "[Stop in ParseAssertResults]" );
00369 cdEXIT(EXIT_FAILURE);
00370 }
00371
00372
00373 strcpy( chAssertLineLabel[nAsserts], chLabel );
00374
00375
00376 i = 5;
00377 wavelength[nAsserts] =
00378 (float)FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00379 if( lgEOL )
00380 {
00381 NoNumb(input.chOrgCard);
00382 }
00383
00384 if( input.chCARDCAPS[i-1] == 'M' )
00385 {
00386
00387 wavelength[nAsserts] *= 1e4;
00388 }
00389 else if( input.chCARDCAPS[i-1] == 'C' )
00390 {
00391
00392 wavelength[nAsserts] *= 1e8;
00393 }
00394
00395
00396
00397 AssertQuantity[nAsserts] =
00398 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00399 if( lgEOL )
00400 {
00401 NoNumb(input.chOrgCard);
00402 }
00403
00404 if( lgQuantityLog[nAsserts] )
00405 {
00406 if( AssertQuantity[nAsserts] > DBL_MAX_10_EXP ||
00407 AssertQuantity[nAsserts] < -DBL_MAX_10_EXP )
00408 {
00409 fprintf( ioQQQ,
00410 " The asserted quantity is a log, but is too large or small, value is %e.\n",AssertQuantity[nAsserts] );
00411 fprintf( ioQQQ, " I would crash if I tried to use it.\n Sorry.\n" );
00412 puts( "[Stop in ParseAssertResults]" );
00413 cdEXIT(EXIT_FAILURE);
00414 }
00415 AssertQuantity[nAsserts] =
00416 pow(10.,AssertQuantity[nAsserts] );
00417 }
00418 if( AssertQuantity[nAsserts]<= 0. )
00419 {
00420 fprintf( ioQQQ,
00421 " The relative intensity must be positive, and was %e.\n",AssertQuantity[nAsserts] );
00422 fprintf( ioQQQ, " Sorry.\n" );
00423 puts( "[Stop in ParseAssertResults]" );
00424 cdEXIT(EXIT_FAILURE);
00425 }
00426
00427
00428 AssertError[nAsserts] =
00429 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00430 if( lgEOL )
00431 {
00432
00433 AssertError[nAsserts] = DEF_ERROR;
00434 }
00435 }
00436
00437
00438 else if( nMatch("DEPA",input.chCARDCAPS ) )
00439 {
00440 i = 5;
00441
00442 AssertQuantity[nAsserts] =
00443 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00444 if( lgEOL )
00445 {
00446 NoNumb(input.chOrgCard);
00447 }
00448
00449
00450 AssertError[nAsserts] =
00451 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00452 if( lgEOL )
00453 {
00454
00455 AssertError[nAsserts] = DEF_ERROR;
00456 }
00457
00458
00459 if( nMatch("H-LI",input.chCARDCAPS ) )
00460 {
00461
00462 strcpy( chAssertLineLabel[nAsserts] , "dHyd" );
00463
00464 strcpy( chAssertType[nAsserts] , "D " );
00465
00466 if( (wavelength[nAsserts] = (float)GetElem(input.chCARDCAPS)) < 0 )
00467 {
00468 fprintf( ioQQQ,
00469 " I could not identify an element name on this line.\n");
00470 fprintf( ioQQQ, " Sorry.\n" );
00471 puts( "[Stop in ParseAssertResults]" );
00472 cdEXIT(EXIT_FAILURE);
00473 }
00474 }
00475
00476
00477 else if( nMatch("HE-L",input.chCARDCAPS ) )
00478 {
00479
00480 strcpy( chAssertLineLabel[nAsserts] , "d He" );
00481
00482 strcpy( chAssertType[nAsserts] , "De" );
00483
00484 if( (wavelength[nAsserts] = (float)GetElem(input.chCARDCAPS)) < 0 )
00485 {
00486 fprintf( ioQQQ,
00487 " I could not identify an element name on this line.\n");
00488 fprintf( ioQQQ, " Sorry.\n" );
00489 puts( "[Stop in ParseAssertResults]" );
00490 cdEXIT(EXIT_FAILURE);
00491 }
00492 }
00493
00494
00495 else if( nMatch("FEII",input.chCARDCAPS ) || nMatch("FE II",input.chCARDCAPS ) )
00496 {
00497
00498 strcpy( chAssertLineLabel[nAsserts] , "d Fe" );
00499
00500 strcpy( chAssertType[nAsserts] , "d " );
00501
00502 wavelength[nAsserts] = 2;
00503 }
00504
00505
00506 else if( nMatch("HMIN",input.chCARDCAPS ) )
00507 {
00508
00509 strcpy( chAssertLineLabel[nAsserts] , "d H-" );
00510
00511 strcpy( chAssertType[nAsserts] , "d-" );
00512
00513 wavelength[nAsserts] = -1;
00514 }
00515 else
00516 {
00517 fprintf( ioQQQ,
00518 " There must be a second key: FEII, H-LIke, HMINus, or HE-Like followed by element.\n");
00519 fprintf( ioQQQ, " Sorry.\n" );
00520 puts( "[Stop in ParseAssertResults]" );
00521 cdEXIT(EXIT_FAILURE);
00522 }
00523
00524
00525 if( nMatch("EXCI",input.chCARDCAPS ) )
00526 {
00527
00528 AssertQuantity2[nAsserts] = 1.;
00529 }
00530 else
00531 {
00532
00533 AssertQuantity2[nAsserts] = 0.;
00534 }
00535 }
00536
00537
00538 else if( nMatch(" MAP",input.chCARDCAPS ) )
00539 {
00540
00541
00542
00543 if( nMatch("HEAT",input.chCARDCAPS ) )
00544 {
00545 strcpy( chAssertType[nAsserts] , "mh" );
00546 }
00547 else if( nMatch("COOL",input.chCARDCAPS ) )
00548 {
00549 strcpy( chAssertType[nAsserts] , "mc" );
00550 }
00551 else
00552 {
00553 fprintf( ioQQQ,
00554 " There must be a second key, HEATing or COOLing.\n");
00555 fprintf( ioQQQ, " Sorry.\n" );
00556 puts( "[Stop in ParseAssertResults]" );
00557 cdEXIT(EXIT_FAILURE);
00558 }
00559
00560
00561
00562 i = 5;
00563 AssertQuantity2[nAsserts] =
00564 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00565 if( lgEOL )
00566 {
00567 NoNumb(input.chOrgCard);
00568 }
00569
00570 if( AssertQuantity2[nAsserts] <= 10. )
00571 {
00572
00573 AssertQuantity2[nAsserts] =
00574 pow(10.,AssertQuantity2[nAsserts] );
00575 }
00576
00577
00578 wavelength[nAsserts] = (float)AssertQuantity2[nAsserts];
00579
00580
00581 AssertQuantity[nAsserts] =
00582 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00583 if( lgEOL )
00584 {
00585 NoNumb(input.chOrgCard);
00586 }
00587
00588
00589 AssertQuantity[nAsserts] = pow(10., AssertQuantity[nAsserts]);
00590
00591
00592
00593 AssertError[nAsserts] =
00594 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00595 if( lgEOL )
00596 {
00597
00598 AssertError[nAsserts] = DEF_ERROR;
00599 }
00600
00601
00602 lgQuantityLog[nAsserts] = true;
00603 }
00604
00605
00606 else if( nMatch("COLU",input.chCARDCAPS ) )
00607 {
00608
00609 strcpy( chAssertType[nAsserts] , "cd" );
00610
00611
00612 wavelength[nAsserts] = 0;
00613
00614
00615
00616
00617 if( (i = nMatch(" H2 ",input.chCARDCAPS )) != 0 )
00618 {
00619 strcpy( chAssertLineLabel[nAsserts], "H2 " );
00620
00621 i += 3;
00622 if( nMatch( "LEVE" , input.chCARDCAPS ) )
00623 {
00624
00625
00626 Param[nAsserts][0] =
00627 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00628 Param[nAsserts][1] =
00629 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00630 if( lgEOL )
00631 NoNumb( input.chCARDCAPS );
00632
00633 wavelength[nAsserts] = (float)(100.*Param[nAsserts][0] + Param[nAsserts][1]);
00634 }
00635 else
00636 {
00637
00638 Param[nAsserts][0] = -1.;
00639 Param[nAsserts][1] = -1.;
00640 }
00641 }
00642 else if( (i = nMatch("H3+ ",input.chCARDCAPS )) != 0 )
00643 {
00644 strcpy( chAssertLineLabel[nAsserts], "H3+ " );
00645
00646 i += 3;
00647 }
00648 else if( (i = nMatch("H2+ ",input.chCARDCAPS )) != 0 )
00649 {
00650 strcpy( chAssertLineLabel[nAsserts], "H2+ " );
00651
00652 i += 3;
00653 }
00654 else if( (i = nMatch(" H- ",input.chCARDCAPS )) != 0 )
00655 {
00656 strcpy( chAssertLineLabel[nAsserts], "H- " );
00657
00658 i += 3;
00659 }
00660 else if( (i = nMatch("H2G ",input.chCARDCAPS )) != 0 )
00661 {
00662 strcpy( chAssertLineLabel[nAsserts], "H2g " );
00663
00664 i += 3;
00665 }
00666 else if( (i = nMatch("H2* ",input.chCARDCAPS )) != 0 )
00667 {
00668 strcpy( chAssertLineLabel[nAsserts], "H2* " );
00669
00670 i += 3;
00671 }
00672 else if( (i = nMatch("HEH+",input.chCARDCAPS )) != 0 )
00673 {
00674 strcpy( chAssertLineLabel[nAsserts], "HeH+" );
00675
00676 i += 3;
00677 }
00678 else if( (i = nMatch(" O2 ",input.chCARDCAPS )) != 0 )
00679 {
00680 strcpy( chAssertLineLabel[nAsserts], "O2 " );
00681
00682 i += 3;
00683 }
00684 else if( (i = nMatch("H2O ",input.chCARDCAPS )) != 0 )
00685 {
00686 strcpy( chAssertLineLabel[nAsserts], "H2O " );
00687
00688 i += 3;
00689 }
00690 else if( (i = nMatch(" C2 ",input.chCARDCAPS ) ) !=0 )
00691 {
00692 strcpy( chAssertLineLabel[nAsserts], "C2 " );
00693
00694 i += 3;
00695 }
00696 else if( (i = nMatch(" C3 ",input.chCARDCAPS ) ) !=0 )
00697 {
00698 strcpy( chAssertLineLabel[nAsserts], "C3 " );
00699
00700 i += 3;
00701 }
00702 else if( nMatch(" CO ",input.chCARDCAPS ) )
00703 {
00704 strcpy( chAssertLineLabel[nAsserts], "CO " );
00705 i = 5;
00706 }
00707 else if( nMatch("SIO ",input.chCARDCAPS ) )
00708 {
00709 strcpy( chAssertLineLabel[nAsserts], "SiO " );
00710 i = 5;
00711 }
00712 else if( nMatch(" OH ",input.chCARDCAPS ) )
00713 {
00714 strcpy( chAssertLineLabel[nAsserts], "OH " );
00715 i = 5;
00716 }
00717 else if( nMatch(" CN ",input.chCARDCAPS ) )
00718 {
00719 strcpy( chAssertLineLabel[nAsserts], "CN " );
00720 i = 5;
00721 }
00722 else if( nMatch(" CH ",input.chCARDCAPS ) )
00723 {
00724 strcpy( chAssertLineLabel[nAsserts], "CH " );
00725 i = 5;
00726 }
00727 else if( nMatch(" CH+",input.chCARDCAPS ) )
00728 {
00729 strcpy( chAssertLineLabel[nAsserts], "CH+ " );
00730 i = 5;
00731 }
00732 else
00733 {
00734 fprintf( ioQQQ,
00735 " I could not identify H2, H3+, H2+, H2g, H2*, H2H+, CO, O2, SiO, OH, C2 or C3 or on this line.\n");
00736 fprintf( ioQQQ, " Sorry.\n" );
00737 puts( "[Stop in ParseAssertResults]" );
00738 cdEXIT(EXIT_FAILURE);
00739 }
00740
00741
00742
00743 AssertQuantity[nAsserts] =
00744 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00745 if( lgEOL )
00746 {
00747 NoNumb(input.chOrgCard);
00748 }
00749
00750 AssertQuantity[nAsserts] =
00751 pow(10.,AssertQuantity[nAsserts] );
00752
00753
00754
00755 AssertError[nAsserts] =
00756 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00757 if( lgEOL )
00758 {
00759
00760 AssertError[nAsserts] = DEF_ERROR;
00761 }
00762
00763
00764
00765 if( nMatch( " LOG" , input.chCARDCAPS ) )
00766 {
00767 AssertError[nAsserts] = pow(10. , AssertError[nAsserts] );
00768 }
00769
00770
00771 lgQuantityLog[nAsserts] = true;
00772 }
00773
00774 else if( nMatch("GRAI",input.chCARDCAPS ) && nMatch(" H2 ",input.chCARDCAPS ) )
00775 {
00776
00777 strcpy( chAssertType[nAsserts] , "g2" );
00778
00779 strcpy( chAssertLineLabel[nAsserts], "R H2" );
00780
00781 i = 5;
00782 nelem =
00783 (long int)FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00784 if( nelem!=2 )
00785 {
00786 fprintf( ioQQQ,
00787 " I did not find a 2, as in H2, as the first number on this line.\n");
00788 fprintf( ioQQQ,
00789 " The rate should be the second number.\n");
00790 fprintf( ioQQQ, " Sorry.\n" );
00791 puts( "[Stop in ParseAssertResults]" );
00792 cdEXIT(EXIT_FAILURE);
00793 }
00794
00795 AssertQuantity[nAsserts] =
00796 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00797 if( lgEOL )
00798 {
00799 NoNumb(input.chOrgCard);
00800 }
00801
00802 if( AssertQuantity[nAsserts] <=0. )
00803 AssertQuantity[nAsserts] = pow(10.,AssertQuantity[nAsserts] );
00804
00805 wavelength[nAsserts] = 0;
00806
00807
00808
00809 AssertError[nAsserts] =
00810 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00811 if( lgEOL )
00812 {
00813
00814 AssertError[nAsserts] = DEF_ERROR;
00815
00816 lgQuantityLog[nAsserts] = true;
00817 }
00818 }
00819
00820
00821 else if( nMatch("TEMP",input.chCARDCAPS ) )
00822 {
00823
00824
00825
00826
00827
00828 if( nMatch("VOLU",input.chCARDCAPS ) )
00829 {
00830 strcpy( chAssertType[nAsserts] , "T ");
00831 }
00832 else
00833 {
00834
00835 strcpy( chAssertType[nAsserts] , "t ");
00836 }
00837
00838
00839
00840 if( nMatch("GRAI",input.chCARDCAPS ) )
00841 {
00842
00843
00844 strcpy( chAssertLineLabel[nAsserts], "GRAI" );
00845
00846
00847 nelem = NDUST-2;
00848
00849
00850
00851
00852
00853 }
00854
00855
00856 else if( nMatch("FACE",input.chCARDCAPS ) )
00857 {
00858 strcpy( chAssertLineLabel[nAsserts], "face" );
00859
00860 nelem = 0;
00861 }
00862
00863
00864 else if( nMatch(" H2 ",input.chCARDCAPS ) )
00865 {
00866 strcpy( chAssertLineLabel[nAsserts], "H2 " );
00867
00868 nelem = 0;
00869 }
00870
00871
00872
00873 else if( (nelem = GetElem(input.chCARDCAPS)) >= 0 )
00874 {
00875
00876
00877 strcpy( chAssertLineLabel[nAsserts], elementnames.chElementNameShort[nelem] );
00878 }
00879 else
00880 {
00881 fprintf( ioQQQ,
00882 " I could not identify an element name on this line.\n");
00883 fprintf( ioQQQ, " Sorry.\n" );
00884 puts( "[Stop in ParseAssertResults]" );
00885 cdEXIT(EXIT_FAILURE);
00886 }
00887
00888
00889 i = 5;
00890 if( strcmp( chAssertLineLabel[nAsserts], "face" )== 0)
00891 {
00892
00893 wavelength[nAsserts] = 0;
00894 }
00895 else if( strcmp( chAssertLineLabel[nAsserts], "H2 " )== 0)
00896 {
00897 int j;
00898
00899 wavelength[nAsserts] = 0;
00900
00901 i = 5;
00902 j = (int)FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00903 if( j != 2 )
00904 TotalInsanity();
00905 ++i;
00906 }
00907 else
00908 {
00909 wavelength[nAsserts] =
00910 (float)FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00911 if( lgEOL )
00912 {
00913 NoNumb(input.chOrgCard);
00914 }
00915
00916 if( wavelength[nAsserts] < 1 || wavelength[nAsserts] > nelem+2 )
00917 {
00918 fprintf( ioQQQ,
00919 " The ionization stage is inappropriate for this element.\n");
00920 fprintf( ioQQQ, " Sorry.\n" );
00921 puts( "[Stop in ParseAssertResults]" );
00922 cdEXIT(EXIT_FAILURE);
00923 }
00924 }
00925
00926
00927 AssertQuantity[nAsserts] =
00928 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00929 if( lgEOL )
00930 {
00931 NoNumb(input.chOrgCard);
00932 }
00933
00934
00935
00936 AssertError[nAsserts] =
00937 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00938 if( lgEOL )
00939 {
00940
00941 AssertError[nAsserts] = DEF_ERROR;
00942 }
00943 if( nMatch( "GRID" , input.chCARDCAPS ) )
00944 {
00945 long int j;
00946
00947
00948 for( j=0; j<optimize.nOptimiz-1; ++j )
00949 {
00950 AssertQuantity[nAsserts] =
00951 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00952 }
00953
00954
00955 if( lgEOL )
00956 {
00957 fprintf(ioQQQ,"this assert grid command does not have enough values. sorry\n");
00958 puts( "[Stop in ParseAssertResults]" );
00959 cdEXIT(EXIT_FAILURE);
00960 }
00961 }
00962
00963
00964
00965 if( AssertQuantity[nAsserts] <= 10. && !nMatch( "LINE" ,input.chCARDCAPS ) )
00966 {
00967
00968 AssertQuantity[nAsserts] =
00969 pow(10.,AssertQuantity[nAsserts] );
00970
00971 lgQuantityLog[nAsserts] = true;
00972 }
00973 }
00974
00975
00976 else if( nMatch("HHEI",input.chCARDCAPS ) )
00977 {
00978
00979 strcpy( chAssertType[nAsserts] , "hh" );
00980
00981 strcpy( chAssertLineLabel[nAsserts], "HHei" );
00982
00983
00984
00985 i = 5;
00986 AssertQuantity[nAsserts] =
00987 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00988 if( lgEOL )
00989 {
00990 NoNumb(input.chOrgCard);
00991 }
00992
00993 wavelength[nAsserts] = 0;
00994
00995
00996
00997 AssertError[nAsserts] =
00998 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
00999 if( lgEOL )
01000 {
01001
01002 AssertError[nAsserts] = DEF_ERROR;
01003 }
01004 }
01005
01006
01007 else if( nMatch(" H2 ",input.chCARDCAPS ) )
01008 {
01009
01010 if( nMatch("ORTH",input.chCARDCAPS ) )
01011 {
01012
01013 strcpy( chAssertType[nAsserts] , "or" );
01014
01015 strcpy( chAssertLineLabel[nAsserts], "orth" );
01016 }
01017 else
01018 {
01019 fprintf( ioQQQ,
01020 " I could not identify a second keyword on this line.\n");
01021 fprintf( ioQQQ, " Sorry.\n" );
01022 puts( "[Stop in ParseAssertResults]" );
01023 cdEXIT(EXIT_FAILURE);
01024 }
01025
01026
01027 i = 5;
01028 n2 = (long)FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01029 if( lgEOL || n2 != 2 )
01030 {
01031 NoNumb(input.chOrgCard);
01032 }
01033 AssertQuantity[nAsserts] =
01034 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01035
01036 wavelength[nAsserts] = 0;
01037
01038
01039
01040 AssertError[nAsserts] =
01041 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01042 if( lgEOL )
01043 {
01044
01045 AssertError[nAsserts] = DEF_ERROR;
01046 }
01047 }
01048
01049
01050 else if( nMatch("NZON",input.chCARDCAPS ) )
01051 {
01052
01053 strcpy( chAssertType[nAsserts] , "z " );
01054
01055 strcpy( chAssertLineLabel[nAsserts], "zone" );
01056
01057
01058 i = 5;
01059 wavelength[nAsserts] =
01060 (float)FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01061 if( lgEOL )
01062 {
01063 NoNumb(input.chOrgCard);
01064 }
01065
01066 AssertQuantity[nAsserts] = (double)wavelength[nAsserts];
01067
01068
01069
01070 AssertError[nAsserts] =
01071 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01072 if( lgEOL )
01073 {
01074
01075 AssertError[nAsserts] = DEF_ERROR;
01076 }
01077 }
01078
01079
01080 else if( nMatch("PRES",input.chCARDCAPS ) )
01081 {
01082
01083 strcpy( chAssertType[nAsserts] , "pr" );
01084
01085 strcpy( chAssertLineLabel[nAsserts], "pres" );
01086
01087
01088
01089 i = 5;
01090 wavelength[nAsserts] = 0;
01091 AssertQuantity[nAsserts] = (double)FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01092 if( lgEOL )
01093 {
01094 NoNumb(input.chOrgCard);
01095 }
01096 else if( AssertQuantity[nAsserts] <= 0.)
01097 {
01098
01099 AssertQuantity[nAsserts] = pow(10. , AssertQuantity[nAsserts]);
01100 }
01101
01102
01103
01104 AssertError[nAsserts] =
01105 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01106 if( lgEOL )
01107 {
01108
01109 AssertError[nAsserts] = DEF_ERROR;
01110 }
01111 }
01112
01113 else if( nMatch("PRAD",input.chCARDCAPS ) && nMatch("DMAX",input.chCARDCAPS ) )
01114 {
01115
01116
01117 strcpy( chAssertType[nAsserts] , "RM" );
01118
01119 strcpy( chAssertLineLabel[nAsserts], "Prad" );
01120
01121
01122
01123 i = 5;
01124 wavelength[nAsserts] = 0;
01125 AssertQuantity[nAsserts] = (double)FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01126 if( lgEOL )
01127 {
01128 NoNumb(input.chOrgCard);
01129 }
01130 else if( AssertQuantity[nAsserts] <= 0.)
01131 {
01132
01133 AssertQuantity[nAsserts] = pow(10. , AssertQuantity[nAsserts]);
01134 }
01135
01136
01137
01138 AssertError[nAsserts] =
01139 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01140 if( lgEOL )
01141 {
01142
01143 AssertError[nAsserts] = DEF_ERROR;
01144 }
01145 }
01146
01147
01148 else if( nMatch("CSUP",input.chCARDCAPS ) )
01149 {
01150
01151 strcpy( chAssertType[nAsserts] , "sc" );
01152
01153 strcpy( chAssertLineLabel[nAsserts], "sion" );
01154
01155
01156 i = 5;
01157 AssertQuantity[nAsserts] =
01158 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01159 if( lgEOL )
01160 {
01161 NoNumb(input.chOrgCard);
01162 }
01163
01164 AssertQuantity[nAsserts] = pow(10., AssertQuantity[nAsserts] );
01165
01166
01167 wavelength[nAsserts] = 0;
01168
01169
01170
01171 AssertError[nAsserts] =
01172 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01173 if( lgEOL )
01174 {
01175
01176 AssertError[nAsserts] = DEF_ERROR;
01177 }
01178
01179
01180 lgQuantityLog[nAsserts] = true;
01181 }
01182
01183
01184 else if( nMatch("HTOT",input.chCARDCAPS ) )
01185 {
01186
01187 strcpy( chAssertType[nAsserts] , "ht" );
01188
01189
01190 strcpy( chAssertLineLabel[nAsserts], "heat" );
01191
01192
01193 i = 5;
01194 AssertQuantity[nAsserts] =
01195 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01196 if( lgEOL )
01197 {
01198 NoNumb(input.chOrgCard);
01199 }
01200
01201 AssertQuantity[nAsserts] = pow(10., AssertQuantity[nAsserts] );
01202
01203
01204 wavelength[nAsserts] = 0;
01205
01206
01207
01208 AssertError[nAsserts] =
01209 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01210 if( lgEOL )
01211 {
01212
01213 AssertError[nAsserts] = DEF_ERROR;
01214 }
01215
01216
01217 lgQuantityLog[nAsserts] = true;
01218 }
01219
01220
01221 else if( nMatch("ITRZ",input.chCARDCAPS ) )
01222 {
01223
01224 strcpy( chAssertType[nAsserts] , "iz" );
01225
01226 strcpy( chAssertLineLabel[nAsserts], "itrz" );
01227
01228
01229 i = 5;
01230 AssertQuantity[nAsserts] =
01231 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01232 if( lgEOL )
01233 {
01234 NoNumb(input.chOrgCard);
01235 }
01236
01237 wavelength[nAsserts] = 0;
01238
01239
01240
01241 AssertError[nAsserts] =
01242 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01243 if( lgEOL )
01244 {
01245
01246
01247
01248 AssertError[nAsserts] = 0.001;
01249 }
01250 }
01251
01252
01253 else if( nMatch("EDEN",input.chCARDCAPS ) )
01254 {
01255
01256 strcpy( chAssertType[nAsserts] , "e " );
01257
01258 strcpy( chAssertLineLabel[nAsserts], "eden" );
01259
01260
01261 i = 5;
01262 AssertQuantity[nAsserts] =
01263 pow(10., FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL) );
01264 if( lgEOL )
01265 {
01266 NoNumb(input.chOrgCard);
01267 }
01268
01269
01270
01271 AssertError[nAsserts] =
01272 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01273 if( lgEOL )
01274 {
01275
01276 AssertError[nAsserts] = DEF_ERROR;
01277 }
01278 wavelength[nAsserts] = 0;
01279
01280
01281 lgQuantityLog[nAsserts] = true;
01282 }
01283
01284
01285 else if( nMatch("THIC",input.chCARDCAPS ) || nMatch("DEPT",input.chCARDCAPS ) )
01286 {
01287
01288 strcpy( chAssertType[nAsserts] , "th" );
01289
01290 strcpy( chAssertLineLabel[nAsserts], "thic" );
01291
01292
01293 i = 5;
01294 AssertQuantity[nAsserts] =
01295 pow(10., FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL) );
01296 if( lgEOL )
01297 {
01298 NoNumb(input.chOrgCard);
01299 }
01300
01301
01302
01303 AssertError[nAsserts] =
01304 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01305 if( lgEOL )
01306 {
01307
01308 AssertError[nAsserts] = DEF_ERROR;
01309 }
01310 wavelength[nAsserts] = 0;
01311
01312
01313 lgQuantityLog[nAsserts] = true;
01314 }
01315
01316
01317 else if( nMatch("RADI",input.chCARDCAPS ) )
01318 {
01319
01320 strcpy( chAssertType[nAsserts] , "ra" );
01321
01322 strcpy( chAssertLineLabel[nAsserts], "radi" );
01323
01324
01325 i = 5;
01326 AssertQuantity[nAsserts] =
01327 pow(10., FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL) );
01328 if( lgEOL )
01329 {
01330 NoNumb(input.chOrgCard);
01331 }
01332
01333
01334
01335 AssertError[nAsserts] =
01336 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01337 if( lgEOL )
01338 {
01339
01340 AssertError[nAsserts] = DEF_ERROR;
01341 }
01342 wavelength[nAsserts] = 0;
01343
01344
01345 lgQuantityLog[nAsserts] = true;
01346 }
01347
01348
01349 else if( nMatch("NITE",input.chCARDCAPS ) )
01350 {
01351
01352 strcpy( chAssertType[nAsserts] , "Z " );
01353
01354 strcpy( chAssertLineLabel[nAsserts], "iter" );
01355
01356
01357 i = 5;
01358 wavelength[nAsserts] =
01359 (float)FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01360 if( lgEOL )
01361 {
01362 NoNumb(input.chOrgCard);
01363 }
01364
01365 AssertQuantity[nAsserts] = (double)wavelength[nAsserts];
01366
01367
01368
01369 AssertError[nAsserts] =
01370 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01371 if( lgEOL )
01372 {
01373
01374 AssertError[nAsserts] = DEF_ERROR;
01375 }
01376 }
01377
01378
01379
01380 else if( nMatch("VELO",input.chCARDCAPS ) )
01381 {
01382
01383 strcpy( chAssertType[nAsserts] , "Ve" );
01384
01385 strcpy( chAssertLineLabel[nAsserts], "vel " );
01386 wavelength[nAsserts] = 0;
01387
01388
01389 i = 5;
01390 AssertQuantity[nAsserts] =
01391 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01392 if( lgEOL )
01393 {
01394 NoNumb(input.chOrgCard);
01395 }
01396
01397
01398
01399 AssertError[nAsserts] =
01400 FFmtRead(input.chCARDCAPS ,&i, INPUT_LINE_LENGTH,&lgEOL);
01401 if( lgEOL )
01402 {
01403
01404 AssertError[nAsserts] = DEF_ERROR;
01405 }
01406 }
01407 else
01408 {
01409
01410 fprintf( ioQQQ,
01411 " Unrecognized command. The line image was==%s==\n",
01412 input.chOrgCard );
01413 fprintf( ioQQQ,
01414 " The options I know about are: ionization, line, departure coefficient, map, column, "
01415 "temperature, nzone, csupre, htot, itrz, eden, thickness, niter, \n");
01416 fprintf( ioQQQ, " Sorry.\n" );
01417 puts( "[Stop in ParseAssertResults]" );
01418 cdEXIT(EXIT_FAILURE);
01419 }
01420
01421
01422 ++nAsserts;
01423 if( nAsserts >= NASSERTS )
01424 {
01425 fprintf(ioQQQ,
01426 " ParseAssertResults: too many asserts, limit is NASSERT=%d\n",
01427 NASSERTS );
01428 puts( "[Stop in ParseAssertResults]" );
01429 cdEXIT(EXIT_FAILURE);
01430 }
01431
01432 DEBUG_EXIT( "ParseAssertResults()" );
01433 return;
01434 }
01435
01436
01437
01438 bool lgCheckAsserts(
01439
01440
01441 FILE * ioASSERT )
01442 {
01443 double PredQuan[NASSERTS] , RelError[NASSERTS];
01444
01445
01446 bool lgFound[NASSERTS];
01447 double relint , absint;
01448 bool lg1OK[NASSERTS];
01449 long i,j;
01450
01451
01452
01453
01454
01455 long ipDisambiguate[NASSERTS][3];
01456 long lgDisambiguate = false;
01457 char chLabelLoc[INPUT_LINE_LENGTH];
01458 char chCaps[5], chFind[5];
01459 float errorwave;
01460
01461 DEBUG_ENTRY( "lgCheckAsserts()" );
01462
01463
01464
01465 lgAssertsOK = true;
01466
01467
01468 lgBigBotch = false;
01469
01470
01471
01472
01473
01474 if( lines_table() )
01475 {
01476 lgBigBotch = true;
01477 lgAssertsOK = false;
01478 }
01479
01480
01481 for(i=0; i<nAsserts; ++i )
01482 {
01483 lg1OK[i] = true;
01484 PredQuan[i] = 0.;
01485 RelError[i] = 0.;
01486 ipDisambiguate[i][0] = -1;
01487 ipDisambiguate[i][1] = -1;
01488 ipDisambiguate[i][2] = -1;
01489
01490
01491 lgFound[i] = true;
01492
01493
01494
01495 if( strcmp( chAssertType[i] , "Lr")==0 )
01496 {
01497
01498 ipDisambiguate[i][0] = cdLine( chAssertLineLabel[i] , wavelength[i] , &relint,&absint );
01499 if( ipDisambiguate[i][0] <= 0 )
01500 {
01501 fprintf( ioASSERT,
01502 " assert error: lgCheckAsserts could not find a line with label %s ",
01503 chAssertLineLabel[i] );
01504 prt_wl( ioASSERT, wavelength[i] );
01505 fprintf( ioASSERT, "\n" );
01506
01507 fprintf( ioASSERT,
01508 " assert error: The \"punch line labels\" command is a good way to get a list of line labels.\n\n");
01509
01510 lg1OK[i] = false;
01511 RelError[i] = 100000.;
01512 PredQuan[i] = 0;
01513 lg1OK[i] = false;
01514 lgAssertsOK = false;
01515 lgFound[i] = false;
01516 continue;
01517 }
01518 else
01519 {
01520
01521
01522
01523
01524
01525 strcpy( chLabelLoc , chAssertLineLabel[i] );
01526
01527 cap4(chFind,chLabelLoc);
01528
01529
01530 errorwave = WavlenErrorGet( wavelength[i] );
01531
01532
01533 for( j=1; j < LineSave.nsum; j++ )
01534 {
01535
01536 if( j==ipDisambiguate[i][0] )
01537 continue;
01538
01539
01540 cap4(chCaps , (char*)LineSv[j].chALab);
01541
01542
01543
01544
01545
01546
01547
01548 if( fabs(LineSv[j].wavelength-wavelength[i]) < 3.f*errorwave )
01549 {
01550
01551 if( strcmp(chCaps,chFind) == 0 )
01552 {
01553 double relint1, absint1, current_error;
01554
01555 cdLine_ip( j, &relint1, &absint1 );
01556 current_error = fabs(1. - relint1/AssertQuantity[i]);
01557
01558 if( current_error < 2.*AssertError[i] ||
01559 current_error < 2.*fabs(RelError[i]) )
01560 {
01561 lgDisambiguate = true;
01562
01563
01564 if( ipDisambiguate[i][1] > 0 )
01565 {
01566 ipDisambiguate[i][2] = j;
01567 break;
01568 }
01569 else
01570 {
01571 ipDisambiguate[i][1] = j;
01572 }
01573 }
01574 }
01575 }
01576 }
01577 }
01578
01579 PredQuan[i] = relint;
01580 RelError[i] = 1. - PredQuan[i]/AssertQuantity[i];
01581 }
01582
01583
01584 else if( strcmp( chAssertType[i] , "Ll")==0 )
01585 {
01586
01587 if( cdLine( chAssertLineLabel[i] , wavelength[i] , &relint,&absint )<=0 )
01588 {
01589 fprintf( ioASSERT,
01590 " assert error: lgCheckAsserts could not find a line with label %s ",
01591 chAssertLineLabel[i] );
01592 prt_wl( ioASSERT, wavelength[i] );
01593 fprintf( ioASSERT, "\n" );
01594
01595 fprintf( ioASSERT,
01596 " assert error: The \"punch line labels\" command is a good way to get a list of line labels.\n\n");
01597
01598 lg1OK[i] = false;
01599 RelError[i] = 10000000.;
01600 PredQuan[i] = 0;
01601 lg1OK[i] = false;
01602 lgFound[i] = false;
01603 lgAssertsOK = false;
01604 continue;
01605 }
01606
01607 PredQuan[i] = pow(10.,absint);
01608 RelError[i] = 1. - PredQuan[i]/AssertQuantity[i];
01609
01610 }
01611 else if( strcmp( chAssertType[i] , "hh" ) == 0)
01612 {
01613 double hfrac , hefrac;
01614
01615 if( cdIonFrac(
01616
01617 "hydr",
01618
01619 1,
01620
01621 &hfrac,
01622
01623 "VOLUME" ,
01624
01625 false) )
01626 {
01627 fprintf( ioASSERT,
01628 " assert error: lgCheckAsserts could not find h ionization fraction \n");
01629 lg1OK[i] = false;
01630 RelError[i] = 0;
01631 PredQuan[i] = 0;
01632 lgFound[i] = false;
01633 continue;
01634 }
01635 if( cdIonFrac(
01636
01637 "heli",
01638
01639 1,
01640
01641 &hefrac,
01642
01643 "VOLUME" ,
01644
01645 false) )
01646 {
01647 fprintf( ioASSERT,
01648 " assert error: lgCheckAsserts could not find h ionization fraction \n");
01649 lg1OK[i] = false;
01650 RelError[i] = 0;
01651 PredQuan[i] = 0;
01652 lgFound[i] = false;
01653 continue;
01654 }
01655
01656 PredQuan[i] = hefrac-hfrac;
01657
01658 RelError[i] = fabs(AssertQuantity[i] - (hefrac-hfrac) );
01659 }
01660
01661 else if( strcmp( chAssertType[i] , "z " ) == 0)
01662 {
01663
01664 PredQuan[i] = (double)nzone;
01665
01666 RelError[i] = (double)(wavelength[i] - nzone);
01667 }
01668
01669 else if( strcmp( chAssertType[i] , "or" ) == 0)
01670 {
01671
01672 PredQuan[i] = h2.ortho_density / SDIV( h2.para_density );
01673
01674
01675 RelError[i] = 1. - PredQuan[i] / AssertQuantity[i];
01676 }
01677
01678 else if( strcmp( chAssertType[i] , "g2" ) == 0)
01679 {
01680
01681 PredQuan[i] = gv.rate_h2_form_grains_used_total;
01682
01683 RelError[i] = 1. - PredQuan[i] / AssertQuantity[i];
01684 }
01685
01686 else if( strcmp( chAssertType[i] , "RM" ) == 0)
01687 {
01688
01689 PredQuan[i] = pressure.RadBetaMax;
01690
01691 RelError[i] = 1. - PredQuan[i] / AssertQuantity[i];
01692 }
01693
01694 else if( strcmp( chAssertType[i] , "pr" ) == 0)
01695 {
01696
01697 double sumx=0., sumx2=0., average;
01698 long int n;
01699
01700 for( n=0; n<nzone; n++ )
01701 {
01702 sumx += struc.pressure[n];
01703 sumx2 += POW2(struc.pressure[n]);
01704 }
01705 if( nzone>1 )
01706 {
01707
01708 average = sumx/nzone;
01709
01710 sumx = sqrt( (sumx2-POW2(sumx)/nzone)/(nzone-1) );
01711
01712 PredQuan[i] = sumx / average;
01713 }
01714 else
01715 {
01716 PredQuan[i] = 0.;
01717 }
01718
01719
01720 RelError[i] = 0.;
01721 }
01722
01723 else if( strcmp( chAssertType[i] , "iz") == 0 )
01724 {
01725
01726 PredQuan[i] = (double)(conv.nTotalIoniz-conv.nTotalIoniz_start)/(double)(nzone);
01727
01728 RelError[i] = 1. - PredQuan[i] / AssertQuantity[i];
01729 }
01730
01731 else if( strcmp( chAssertType[i] , "e ") == 0 )
01732 {
01733
01734 PredQuan[i] = dense.eden;
01735
01736 RelError[i] = 1. - PredQuan[i] / AssertQuantity[i];
01737 }
01738
01739 else if( strcmp( chAssertType[i] , "th") == 0 )
01740 {
01741
01742 PredQuan[i] = radius.depth;
01743
01744 RelError[i] = 1. - PredQuan[i] / AssertQuantity[i];
01745 }
01746
01747 else if( strcmp( chAssertType[i] , "ra") == 0 )
01748 {
01749
01750 PredQuan[i] = radius.Radius;
01751
01752 RelError[i] = 1. - PredQuan[i] / AssertQuantity[i];
01753 }
01754
01755 else if( strcmp( chAssertType[i] , "Ve") == 0 )
01756 {
01757
01758 PredQuan[i] = wind.windv/1e5;
01759
01760 RelError[i] = 1. - PredQuan[i] / AssertQuantity[i];
01761 }
01762
01763 else if( strcmp( chAssertType[i] , "sc") == 0 )
01764 {
01765
01766 PredQuan[i] = secondaries.csupra[ipHYDROGEN][0];
01767
01768 RelError[i] = 1. - PredQuan[i] / AssertQuantity[i];
01769 }
01770
01771 else if( strcmp( chAssertType[i] , "ht") == 0 )
01772 {
01773
01774 PredQuan[i] = thermal.htot;
01775
01776 RelError[i] = 1. - PredQuan[i] / AssertQuantity[i];
01777 }
01778
01779 else if( strcmp( chAssertType[i] , "Z ") == 0 )
01780 {
01781
01782 PredQuan[i] = (double)iteration;
01783
01784 RelError[i] = (double)(wavelength[i] - iteration);
01785
01786 AssertError[i] = 0.;
01787 }
01788
01789 else if( strcmp( chAssertType[i] , "D ") == 0 )
01790 {
01791 long ipZ , n;
01792
01793
01794 ipZ = (long)wavelength[i];
01795 if( !dense.lgElmtOn[ipZ] )
01796 {
01797 fprintf(ioQQQ," asserted element %ld is not turned on!\n",ipZ);
01798 PredQuan[i] = 0;
01799 RelError[i] = 0.;
01800 }
01801 else
01802 {
01803 RelError[i] = 0.;
01804 PredQuan[i] = 0.;
01805 for( n=(long)AssertQuantity2[i]; n<iso.numPrintLevels[ipH_LIKE][ipZ]; ++n )
01806 {
01807 PredQuan[i] += iso.DepartCoef[ipH_LIKE][ipZ][n];
01808
01809 RelError[i] = MAX2( RelError[i] , iso.DepartCoef[ipH_LIKE][ipZ][n] -1.);
01810 RelError[i] = MAX2( RelError[i] , 1. - iso.DepartCoef[ipH_LIKE][ipZ][n] );
01811 }
01812 PredQuan[i] /= (double)(iso.numPrintLevels[ipH_LIKE][ipZ]);
01813 RelError[i] /= (double)(iso.numPrintLevels[ipH_LIKE][ipZ]);
01814 }
01815 }
01816
01817
01818 else if( strcmp( chAssertType[i] , "De") == 0 )
01819 {
01820 long ipZ , n;
01821
01822
01823 ipZ = (long)wavelength[i];
01824 if( !dense.lgElmtOn[ipZ] )
01825 {
01826 fprintf(ioQQQ," asserted element %ld is not turned on!\n",ipZ);
01827 PredQuan[i] = 0.;
01828 RelError[i] = 0.;
01829 }
01830 else
01831 {
01832 RelError[i] = 0.;
01833 PredQuan[i] = 0.;
01834 for( n=(long)AssertQuantity2[i]; n<iso.numPrintLevels[ipHE_LIKE][ipZ]; ++n )
01835 {
01836 double relerror;
01837 relerror = 0.;
01838 PredQuan[i] += iso.DepartCoef[ipHE_LIKE][ipZ][n];
01839
01840 relerror = iso.DepartCoef[ipHE_LIKE][ipZ][n] -1.;
01841 relerror = MAX2( relerror , 1. - iso.DepartCoef[ipHE_LIKE][ipZ][n] );
01842 RelError[i] = MAX2( RelError[i] , relerror / AssertQuantity[i] );
01843 }
01844 PredQuan[i] /= (double)(iso.numPrintLevels[ipHE_LIKE][ipZ]);
01845
01846 RelError[i] /= (double)(iso.numPrintLevels[ipHE_LIKE][ipZ]);
01847 }
01848 }
01849
01850
01851 else if( strcmp( chAssertType[i] , "d ") == 0 )
01852 {
01853 double BigError , StdDev;
01854
01855 AssertFeIIDep( &PredQuan[i] , &BigError , &StdDev );
01856
01857
01858
01859 RelError[i] = StdDev;
01860 }
01861
01862
01863 else if( strcmp( chAssertType[i] , "d-") == 0 )
01864 {
01865 PredQuan[i] = hmi.hmidep;
01866 RelError[i] = fabs( hmi.hmidep - 1.);
01867 }
01868
01869
01870 else if( (strcmp( chAssertType[i] , "f ") == 0) ||
01871 (strcmp( chAssertType[i] , "F ") == 0) )
01872 {
01873 char chWeight[7];
01874 if( strcmp( chAssertType[i] , "F ") == 0 )
01875 {
01876 strcpy( chWeight , "VOLUME" );
01877 }
01878 else
01879 {
01880
01881 strcpy( chWeight , "RADIUS" );
01882 }
01883
01884 if( cdIonFrac(
01885
01886 chAssertLineLabel[i],
01887
01888 (long)wavelength[i],
01889
01890 &relint,
01891
01892 chWeight ,
01893
01894 false) )
01895 {
01896 fprintf( ioASSERT,
01897 " assert error: lgCheckAsserts could not find a line with label %s %f \n",
01898 chAssertLineLabel[i] , wavelength[i] );
01899
01900 lg1OK[i] = false;
01901 RelError[i] = 0;
01902 PredQuan[i] = 0;
01903 lgFound[i] = false;
01904 continue;
01905 }
01906
01907 PredQuan[i] = relint;
01908 RelError[i] = 1. - PredQuan[i]/AssertQuantity[i];
01909 }
01910
01911
01912 else if( strcmp( chAssertType[i] , "cd") == 0)
01913 {
01914
01915 if( (strcmp( chAssertLineLabel[i], "H2 " ) == 0) && (Param[i][0] >= 0.) )
01916 {
01917
01918
01919 if( (relint = cdH2_colden( (long)Param[i][0] , (long)Param[i][1] ) ) < 0. )
01920 {
01921 fprintf(ioQQQ," PROBLEM lgCheckAsserts did not find v=%li, J=%li for H2 column density.\n",
01922 (long)Param[i][0] , (long)Param[i][1] );
01923 lg1OK[i] = false;
01924 RelError[i] = 0;
01925 PredQuan[i] = 0;
01926 lgFound[i] = false;
01927 continue;
01928 }
01929 }
01930 else
01931 {
01932
01933 if( cdColm(
01934
01935 chAssertLineLabel[i],
01936
01937
01938 (long)wavelength[i],
01939
01940 &relint) )
01941 {
01942 fprintf( ioASSERT,
01943 " assert error: lgCheckAsserts could not find a molecule with label %s %f \n",
01944 chAssertLineLabel[i] , wavelength[i] );
01945
01946 lg1OK[i] = false;
01947 RelError[i] = 0;
01948 PredQuan[i] = 0;
01949 lgFound[i] = false;
01950 continue;
01951 }
01952 }
01953
01954 PredQuan[i] = relint;
01955 RelError[i] = 1. - PredQuan[i]/AssertQuantity[i];
01956 }
01957
01958
01959 else if( (strcmp( chAssertType[i] , "MF") == 0) || (strcmp( chAssertType[i] , "mf") == 0) )
01960 {
01961
01962 relint = 0.;
01963 if( strcmp( chAssertLineLabel[i], "H2 ") ==0)
01964 {
01965
01966 if( cdColm("H2 " , 0,
01967
01968 &relint) )
01969 TotalInsanity();
01970
01971 relint = relint / colden.colden[ipCOL_HTOT];
01972 }
01973 else
01974 {
01975 fprintf( ioASSERT,
01976 " assert error: lgCheckAsserts could not find a molecule with label %s %f \n",
01977 chAssertLineLabel[i] , wavelength[i] );
01978
01979 lg1OK[i] = false;
01980 RelError[i] = 0;
01981 PredQuan[i] = 0;
01982 continue;
01983 }
01984
01985 PredQuan[i] = relint;
01986 RelError[i] = 1. - PredQuan[i]/AssertQuantity[i];
01987 }
01988
01989
01990 else if( strcmp( chAssertType[i] , "mh") == 0 || strcmp( chAssertType[i] , "mc") == 0)
01991 {
01992
01993
01994 if( map.nMapAlloc == 0 )
01995 {
01996
01997 fprintf( ioASSERT,
01998 " assert error: lgCheckAsserts cannot check map since map not done.\n");
01999
02000 lg1OK[i] = false;
02001 RelError[i] = 0;
02002 PredQuan[i] = 0;
02003 continue;
02004 }
02005
02006 if( AssertQuantity2[i]< map.temap[0] || AssertQuantity2[i]> map.temap[map.nmap-1] )
02007 {
02008 fprintf( ioASSERT,
02009 " assert error: lgCheckAsserts cannot check map since temperature not within range.\n");
02010
02011 lg1OK[i] = false;
02012 RelError[i] = 0;
02013 PredQuan[i] = 0;
02014 continue;
02015 }
02016
02017
02018 j = 0;
02019 while( AssertQuantity2[i]>map.temap[j]*1.001 && j < map.nmap )
02020 {
02021 ++j;
02022 }
02023
02024
02025
02026 if( strcmp( chAssertType[i] , "mh") == 0 )
02027 {
02028
02029 PredQuan[i] = map.hmap[j];
02030 strcpy(chAssertLineLabel[i],"MapH" );
02031 }
02032 else if( strcmp( chAssertType[i] , "mc") == 0)
02033 {
02034
02035 PredQuan[i] = map.cmap[j];
02036 strcpy(chAssertLineLabel[i],"MapC" );
02037 }
02038 RelError[i] = 1. - PredQuan[i]/AssertQuantity[i];
02039 }
02040
02041
02042 else if( (strcmp( chAssertType[i] , "t ") == 0) ||
02043 (strcmp( chAssertType[i] , "T ") == 0) )
02044 {
02045 char chWeight[7];
02046 if( strcmp( chAssertType[i] , "T ") == 0 )
02047 {
02048 strcpy( chWeight , "VOLUME" );
02049 }
02050 else
02051 {
02052
02053 strcpy( chWeight , "RADIUS" );
02054 }
02055
02056
02057 if( strcmp( chAssertLineLabel[i], "GRAI" ) == 0 )
02058 {
02059 long nd;
02060
02061
02062 nd = (long)(wavelength[i]-1);
02063 if( nd < 0 || nd >= gv.nBin ) {
02064 fprintf( ioQQQ, "Illegal grain number found: %f\n" , wavelength[i] );
02065 fprintf( ioQQQ, "Use 1 for first grain that is turned on, " );
02066 fprintf( ioQQQ, "2 for second, etc....\n" );
02067 fprintf( ioQQQ, "Old style grain numbers are not valid anymore !!\n" );
02068 puts( "[Stop in ParseAssertResults]" );
02069 cdEXIT(EXIT_FAILURE);
02070 }
02071 ASSERT( nd>= 0 );
02072 relint = gv.bin[nd]->avdust/radius.depth_x_fillfac;
02073 }
02074 else if( strcmp( chAssertLineLabel[i], "face" ) == 0 )
02075 {
02076
02077 relint = struc.testr[0];
02078 }
02079 else
02080 {
02081
02082 if( cdTemp(
02083
02084 chAssertLineLabel[i],
02085
02086 (long)wavelength[i],
02087
02088 &relint,
02089
02090 chWeight ) )
02091 {
02092 fprintf( ioASSERT,
02093 " assert error: lgCheckAsserts could not find an ion with label %s ion %li \n",
02094 chAssertLineLabel[i] , (long)wavelength[i] );
02095
02096 lg1OK[i] = false;
02097 RelError[i] = 0;
02098 PredQuan[i] = 0;
02099 lgFound[i] = false;
02100 continue;
02101 }
02102 }
02103
02104 PredQuan[i] = relint;
02105 RelError[i] = 1. - PredQuan[i]/AssertQuantity[i];
02106 }
02107
02108 else
02109 {
02110 fprintf( ioASSERT,
02111 " assert error: lgCheckAsserts received an insane chAssertType=%s, impossible\n",
02112 chAssertType[i] );
02113 ShowMe();
02114 puts( "[Stop in ParseAssertResults]" );
02115 cdEXIT(EXIT_FAILURE);
02116 }
02117
02118 if( chAssertLimit[i] == '=' )
02119 {
02120
02121 if( fabs(RelError[i]) > AssertError[i] )
02122 {
02123 lg1OK[i] = false;
02124 lgAssertsOK = false;
02125 }
02126 }
02127 else if( chAssertLimit[i] == '<' )
02128 {
02129
02130
02131
02132
02133
02134 if( RelError[i] <= 0.-AssertError[i])
02135 {
02136 lg1OK[i] = false;
02137 lgAssertsOK = false;
02138 }
02139 }
02140 else if( chAssertLimit[i] == '>' )
02141 {
02142
02143
02144 if( RelError[i] >= 0.+AssertError[i])
02145 {
02146 lg1OK[i] = false;
02147 lgAssertsOK = false;
02148 }
02149 }
02150 }
02151
02152
02153 if( called.lgTalk && nAsserts>0 )
02154 {
02155 char chVer[10];
02156 time_t now;
02157 cdVersion(chVer );
02158
02159
02160 if( lgDisambiguate )
02161 {
02162
02163 long sigfigsav = LineSave.sig_figs;
02164 double relint1, relint2, absint1;
02165
02166 LineSave.sig_figs = 6;
02167
02168 fprintf( ioASSERT, "=============Line Disambiguation=======================================================\n" );
02169 fprintf( ioASSERT, " Wavelengths || Intensities \n" );
02170 fprintf( ioASSERT, "Label line match1 match2 match3 || asserted match1 match2 match3\n" );
02171
02172 for( i=0; i<nAsserts; ++i )
02173 {
02174 if( ipDisambiguate[i][1] > 0 )
02175 {
02176 fprintf( ioASSERT , "%4s ", chAssertLineLabel[i] );
02177 prt_wl( ioASSERT , wavelength[i] );
02178 fprintf( ioASSERT , " " );
02179 prt_wl( ioASSERT , LineSv[ipDisambiguate[i][0]].wavelength );
02180 fprintf( ioASSERT , " " );
02181 prt_wl( ioASSERT , LineSv[ipDisambiguate[i][1]].wavelength );
02182 fprintf( ioASSERT , " " );
02183 if( ipDisambiguate[i][2] > 0 )
02184 {
02185 prt_wl( ioASSERT , LineSv[ipDisambiguate[i][2]].wavelength );
02186 cdLine_ip( ipDisambiguate[i][2], &relint2, &absint1 );
02187 }
02188 else
02189 {
02190 fprintf( ioASSERT , "--------" );
02191 relint2 = 0.0;
02192 }
02193 fprintf( ioASSERT , " ||" );
02194
02195 cdLine_ip( ipDisambiguate[i][1], &relint1, &absint1 );
02196
02197 if( lgPrtSciNot )
02198 {
02199 fprintf( ioASSERT , " %10.3e %10.3e %10.3e %10.3e\n",
02200 AssertQuantity[i],
02201 PredQuan[i] ,
02202 relint1,
02203 relint2 );
02204 }
02205 else
02206 {
02207 fprintf( ioASSERT , " %10.4f %10.4f %10.4f %10.4f\n",
02208 AssertQuantity[i],
02209 PredQuan[i] ,
02210 relint1,
02211 relint2 );
02212 }
02213 }
02214 }
02215 fprintf( ioASSERT, "\n" );
02216
02217
02218 LineSave.sig_figs = sigfigsav;
02219 }
02220
02221
02222 fprintf( ioASSERT, "=============Results of asserts: C%s ",chVer );
02223
02224
02225
02226 if( prt.lgPrintTime )
02227 {
02228
02229 now = time(NULL);
02230
02231 fprintf(ioASSERT,"%s", ctime(&now) );
02232 }
02233 else
02234 {
02235 fprintf(ioASSERT,"\n" );
02236 }
02237
02238 if( lgAssertsOK )
02239 {
02240 fprintf( ioASSERT, " No errors were found. Summary follows.\n");
02241 }
02242 else
02243 {
02244 fprintf( ioASSERT, " Errors were found. Summary follows.\n");
02245 }
02246
02247 fprintf( ioASSERT,
02248 " Label line computed asserted Rel Err Set err\n");
02249
02250
02251 for( i=0; i<nAsserts; ++i )
02252 {
02253 double prtPredQuan, prtAssertQuantity;
02254
02255
02256 if( lgQuantityLog[i] )
02257 {
02258 prtPredQuan = log10( MAX2( SMALLDOUBLE , PredQuan[i] ) );
02259 prtAssertQuantity = log10( MAX2( SMALLDOUBLE , AssertQuantity[i] ) );
02260 }
02261 else
02262 {
02263 prtPredQuan = PredQuan[i];
02264 prtAssertQuantity = AssertQuantity[i];
02265 }
02266
02267 if( lg1OK[i] )
02268 {
02269
02270
02271 double relative = fabs(RelError[i] / SDIV( AssertError[i]));
02272
02273 if( relative < 0.25 || chAssertLimit[i] != '=' )
02274 {
02275 fprintf( ioASSERT, " ChkAssert ");
02276 }
02277 else if( relative < 0.50 )
02278 {
02279 fprintf( ioASSERT, " ChkAssert - ");
02280 }
02281 else if( relative < 0.75 )
02282 {
02283 fprintf( ioASSERT, " ChkAssert -- ");
02284 }
02285 else if( relative < 0.90 )
02286 {
02287 fprintf( ioASSERT, " ChkAssert --- ");
02288 }
02289 else if( relative < 0.95 )
02290 {
02291 fprintf( ioASSERT, " ChkAssert ---- ");
02292 }
02293 else if( relative < 0.98 )
02294 {
02295 fprintf( ioASSERT, " ChkAssert ----- ");
02296 }
02297 else
02298 {
02299 fprintf( ioASSERT, " ChkAssert ------ ");
02300 }
02301
02302 }
02303 else
02304 {
02305 fprintf( ioASSERT, " ChkAssert botch>>");
02306 }
02307 if( strcmp( chAssertType[i] , "Ll")==0 || ( strcmp( chAssertType[i] , "Lr")==0 ) )
02308 {
02309
02310 fprintf( ioASSERT , "%4s ",
02311 chAssertLineLabel[i] );
02312
02313 prt_wl( ioASSERT , wavelength[i] );
02314
02315 if( lgPrtSciNot )
02316 {
02317 fprintf( ioASSERT , " %10.3e %c %10.3e %7.3f %7.3f ",
02318 prtPredQuan ,
02319 chAssertLimit[i] ,
02320 prtAssertQuantity ,
02321 RelError[i] ,
02322 AssertError[i]);
02323 }
02324 else
02325 {
02326 fprintf( ioASSERT , " %10.4f %c %10.4f %7.3f %7.3f ",
02327 prtPredQuan ,
02328 chAssertLimit[i] ,
02329 prtAssertQuantity ,
02330 RelError[i] ,
02331 AssertError[i]);
02332 }
02333
02334 {
02335
02336 enum {DEBUG_LOC=false};
02337
02338
02339 if( DEBUG_LOC )
02340 {
02341 long ipHi, ipLo;
02342 errorwave = WavlenErrorGet( wavelength[i] );
02343
02344 for( ipLo = ipHe1s1S; ipLo <= iso.numLevels_local[ipHE_LIKE][ipHELIUM] -
02345 iso.nCollapsed_local[ipHE_LIKE][ipHELIUM]; ipLo ++ )
02346 {
02347 for( ipHi = ipLo+1; ipHi < iso.numLevels_local[ipHE_LIKE][ipHELIUM] -
02348 iso.nCollapsed_local[ipHE_LIKE][ipHELIUM]; ipHi++ )
02349 {
02350 if( fabs(EmisLines[ipHE_LIKE][ipHELIUM][ipHi][ipLo].WLAng - wavelength[i])
02351 < errorwave && ipLo!=ipHe2p3P0 && ipLo!=ipHe2p3P1 )
02352 {
02353 fprintf( ioQQQ, "\t%li %li %li %li %li %li",
02354 iso.quant_desig[ipHE_LIKE][ipHELIUM][ipHi].n,
02355 iso.quant_desig[ipHE_LIKE][ipHELIUM][ipHi].l,
02356 iso.quant_desig[ipHE_LIKE][ipHELIUM][ipHi].s,
02357 iso.quant_desig[ipHE_LIKE][ipHELIUM][ipLo].n,
02358 iso.quant_desig[ipHE_LIKE][ipHELIUM][ipLo].l,
02359 iso.quant_desig[ipHE_LIKE][ipHELIUM][ipLo].s );
02360 break;
02361 }
02362 }
02363 }
02364 }
02365 }
02366
02367 }
02368 else
02369 {
02370 fprintf( ioASSERT , "%4s %6i %10.4f %c %10.4f %7.3f %7.3f ",
02371 chAssertLineLabel[i] ,
02372 (int)wavelength[i] ,
02373 prtPredQuan ,
02374 chAssertLimit[i] ,
02375 prtAssertQuantity ,
02376 RelError[i] ,
02377 AssertError[i]);
02378 }
02379
02380
02381
02382
02383
02384
02385 if( !lg1OK[i] && (fabs(RelError[i]) > 3.*AssertError[i]) && lgFound[i] )
02386 {
02387 fprintf( ioASSERT , " <<BIG BOTCH!!\n");
02388 lgBigBotch = true;
02389 }
02390 else
02391 {
02392 fprintf( ioASSERT , "\n");
02393 }
02394 }
02395
02396 fprintf( ioASSERT , " \n");
02397
02398
02399
02400 if( !lgAssertsOK && lgBigBotch )
02401 {
02402
02403 fprintf( ioASSERT, " BIG BOTCHED ASSERTS!!! Big Botched Asserts!!! \n");
02404 }
02405 else if( !lgAssertsOK )
02406 {
02407 fprintf( ioASSERT, " BOTCHED ASSERTS!!! Botched Asserts!!! \n");
02408 }
02409
02410 if( !lgAssertsOK )
02411 {
02412 fprintf( ioQQQ, " %s\n\n", version.chInfo );
02413 }
02414 }
02415
02416 DEBUG_EXIT( "lgCheckAsserts()" );
02417 return lgAssertsOK;
02418 }
02419