IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 27597 for trunk/psModules


Ignore:
Timestamp:
Apr 5, 2010, 10:34:47 AM (16 years ago)
Author:
Paul Price
Message:

Removing unnecessary code that was assuming pthread_t == unsigned int.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psModules/src/detrend/pmDark.c

    r24869 r27597  
    3838    if (!item) {
    3939        pmChip *chip = cell->parent; // Parent chip
    40         psAssert(chip, "cell is missing chip \n");
     40        psAssert(chip, "cell is missing chip \n");
    4141
    4242        item = psMetadataLookup(chip->concepts, name);
    4343        if (!item) {
    4444            pmFPA *fpa = chip->parent; // Parent FPA
    45             psAssert(fpa, "chip is missing fpa \n");
     45            psAssert(fpa, "chip is missing fpa \n");
    4646
    4747            item = psMetadataLookup(fpa->concepts, name);
    … …  
    6868
    6969    psArray *words = psStringSplitArray(rule, " ", false);
    70    
     70
    7171    // we should have a rule of the form (concept) OP (concept) OP (concept) ...
    7272    // for now, the only allowed OP is * (eventually, we can steal code from opihi for a better
    … …  
    7474
    7575    if (words->n % 2 == 0) {
    76         psError(PM_ERR_CONFIG, true, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
    77         psFree(words);
    78         return false;
     76        psError(PM_ERR_CONFIG, true, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
     77        psFree(words);
     78        return false;
    7979    }
    8080
    8181    for (int i = 1; i < words->n; i+=2) {
    82         if (strcmp((char *)words->data[i], "*")) {
    83             psError(PM_ERR_CONFIG, true, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
    84             psFree(words);
    85             return false;
    86         }
    87     }
    88    
     82        if (strcmp((char *)words->data[i], "*")) {
     83            psError(PM_ERR_CONFIG, true, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
     84            psFree(words);
     85            return false;
     86        }
     87    }
     88
    8989    if (!ordinateParseConcept(value, readout, words->data[0])) {
    90         psError(PM_ERR_CONFIG, false, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
    91         psFree(words);
    92         return false;
     90        psError(PM_ERR_CONFIG, false, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
     91        psFree(words);
     92        return false;
    9393    }
    9494
    9595    double value2 = 0.0;
    9696    for (int i = 2; i < words->n; i+=2) {
    97         if (!ordinateParseConcept(&value2, readout, words->data[i])) {
    98             psError(PM_ERR_CONFIG, false, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
    99             psFree(words);
    100             return false;
    101         }
    102         *value *= value2;
     97        if (!ordinateParseConcept(&value2, readout, words->data[i])) {
     98            psError(PM_ERR_CONFIG, false, "syntax error in DARK.ORDINATE %s rule %s\n", name, rule);
     99            psFree(words);
     100            return false;
     101        }
     102        *value *= value2;
    103103    }
    104104    psFree(words);
    … …  
    123123
    124124    if (rule) {
    125         if (!ordinateParseRule(value, readout, name, rule)) {
    126             psError(PM_ERR_CONFIG, false, "trouble parsing rule %s for DARK.ORDINATE %s", rule, name);
    127             return false;
    128         }
     125        if (!ordinateParseRule(value, readout, name, rule)) {
     126            psError(PM_ERR_CONFIG, false, "trouble parsing rule %s for DARK.ORDINATE %s", rule, name);
     127            return false;
     128        }
    129129    } else {
    130         if (!ordinateParseConcept(value, readout, name)) {
    131             psError(PM_ERR_CONFIG, false, "trouble parsing rule %s for DARK.ORDINATE %s", rule, name);
    132             return false;
    133         }
     130        if (!ordinateParseConcept(value, readout, name)) {
     131            psError(PM_ERR_CONFIG, false, "trouble parsing rule %s for DARK.ORDINATE %s", rule, name);
     132            return false;
     133        }
    134134    }
    135135
    … …  
    188188        double normValue;            // Normalisation value
    189189        if (!ordinateLookup(&normValue, &inRange, normConcept, NULL, false, NAN, NAN, readout)) {
    190             psError(PM_ERR_CONFIG, false, "problem finding concept %s for DARK.NORM", normConcept);
    191             return false;
    192         }
    193         if (!isfinite(normValue)) {
     190            psError(PM_ERR_CONFIG, false, "problem finding concept %s for DARK.NORM", normConcept);
     191            return false;
     192        }
     193        if (!isfinite(normValue)) {
    194194            psWarning("Unable to find acceptable value of %s for readout %d", normConcept, i);
    195195            roMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff;
    … …  
    231231            double value = NAN;          // Value of ordinate
    232232            if (!ordinateLookup(&value, &inRange, ord->name, ord->rule, ord->scale, ord->min, ord->max, readout)) {
    233                 psError(PM_ERR_CONFIG, false, "problem finding rule for DARK.ORDINATE %s", ord->name);
    234                 return false;
    235             }
    236             if (!isfinite(value)) {
    237                 psWarning("Unable to find acceptable value of DARK.ORDINATE %s for readout %d", ord->name, i);
     233                psError(PM_ERR_CONFIG, false, "problem finding rule for DARK.ORDINATE %s", ord->name);
     234                return false;
     235            }
     236            if (!isfinite(value)) {
     237                psWarning("Unable to find acceptable value of DARK.ORDINATE %s for readout %d", ord->name, i);
    238238                roMask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xff;
    239239                val->data.F32[i] = NAN;
    … …  
    242242            }
    243243            if (!inRange) {
    244                 psWarning("Value of DARK.ORDINATE %s for readout %d is out of range", ord->name, i);
     244                psWarning("Value of DARK.ORDINATE %s for readout %d is out of range", ord->name, i);
    245245                roMask->data.PS_TYPE_VECTOR_MASK_DATA[j] = 0xff;
    246246                val->data.F32[i] = NAN;
    … …  
    349349    PS_ASSERT_INT_NONNEGATIVE(iter, false);
    350350    PS_ASSERT_FLOAT_LARGER_THAN(rej, 0.0, false);
    351 
    352     pthread_t id = pthread_self();
    353     char name[64];
    354     sprintf (name, "%x", (unsigned int) id);
    355     psTimerStart (name);
    356351
    357352    bool mdok = false;
    … …  
    433428            }
    434429
    435             pmDarkVisualPixelFit(pixels, mask);
    436             pmDarkVisualPixelModel(poly, values);
     430            pmDarkVisualPixelFit(pixels, mask);
     431            pmDarkVisualPixelModel(poly, values);
    437432
    438433            for (int k = 0; k < poly->coeff->n; k++) {
    … …  
    537532            return false;
    538533        }
    539         if (!isfinite(value)) {
     534        if (!isfinite(value)) {
    540535            psError(PS_ERR_UNKNOWN, true, "Value for DARK.ORDINATE %s is NAN", ord->name);
    541536            psFree(values);
    542537            return false;
    543         }
     538        }
    544539        values->data.F32[i] = value;
    545540    }
    … …  
    792787            psMetadataAddStr(row, PS_LIST_TAIL, PM_DARK_FITS_NAME, 0, "DARK.ORDINATE name", ord->name);
    793788
    794             // XXX write a dummy value if ord->rule == NULL? (eg, NONE)
    795             if (ord->rule) {
    796                 psMetadataAddStr(row, PS_LIST_TAIL, PM_DARK_FITS_RULE, 0, "DARK.ORDINATE rule", ord->rule);
    797             } else {
    798                 psMetadataAddStr(row, PS_LIST_TAIL, PM_DARK_FITS_RULE, 0, "DARK.ORDINATE rule", "NONE");
    799             }
     789            // XXX write a dummy value if ord->rule == NULL? (eg, NONE)
     790            if (ord->rule) {
     791                psMetadataAddStr(row, PS_LIST_TAIL, PM_DARK_FITS_RULE, 0, "DARK.ORDINATE rule", ord->rule);
     792            } else {
     793                psMetadataAddStr(row, PS_LIST_TAIL, PM_DARK_FITS_RULE, 0, "DARK.ORDINATE rule", "NONE");
     794            }
    800795
    801796            psMetadataAddS32(row, PS_LIST_TAIL, PM_DARK_FITS_ORDER, 0, "Polynomial order", ord->order);
    … …  
    975970              ord->max = psMetadataLookupF32(NULL, row, PM_DARK_FITS_MAX);
    976971
    977               // load the ordinate rule; it is not an error if this field is missing or NULL
    978               // a NULL rule means 'use the name as the single concept'
     972              // load the ordinate rule; it is not an error if this field is missing or NULL
     973              // a NULL rule means 'use the name as the single concept'
    979974              const char *rule = psMetadataLookupStr(&mdok, row, PM_DARK_FITS_RULE);
    980               if (!rule || !strcasecmp(rule, "NONE")) {
    981                   ord->rule = NULL;
    982               } else {
    983                   ord->rule = psStringCopy(rule);
    984               }
     975              if (!rule || !strcasecmp(rule, "NONE")) {
     976                  ord->rule = NULL;
     977              } else {
     978                  ord->rule = psStringCopy(rule);
     979              }
    985980              ordinates->data[i] = ord;
    986981          }
    … …  
    10091004// this init function only gets the ordinates for the first readout...
    10101005bool pmDarkVisualInit(psArray *values) {
    1011    
     1006
    10121007    if (!pmVisualIsVisual()) return true;
    10131008
    … …  
    10181013    int nOrders = 0;
    10191014    for (int i = 0; i < values->n; i++) {
    1020         psVector *vect = values->data[i];
    1021         if (!nOrders) {
    1022             nOrders = vect->n;
    1023         } else {
    1024             psAssert (nOrders == vect->n, "mismatch in order vector lengths");
    1025         }
     1015        psVector *vect = values->data[i];
     1016        if (!nOrders) {
     1017            nOrders = vect->n;
     1018        } else {
     1019            psAssert (nOrders == vect->n, "mismatch in order vector lengths");
     1020        }
    10261021    }
    10271022    xVectors = psArrayAlloc(nOrders);
    10281023    for (int i = 0; i < nOrders; i++) {
    1029         xVectors->data[i] = psVectorAlloc(values->n, PS_TYPE_F32);
     1024        xVectors->data[i] = psVectorAlloc(values->n, PS_TYPE_F32);
    10301025    }
    10311026
    10321027    for (int i = 0; i < values->n; i++) {
    1033         psVector *vect = values->data[i];
    1034         for (int j = 0; j < vect->n; j++) {
    1035             psVector *xVec = xVectors->data[j];
    1036             xVec->data.F32[i] = vect->data.F32[j];
    1037         }
     1028        psVector *vect = values->data[i];
     1029        for (int j = 0; j < vect->n; j++) {
     1030            psVector *xVec = xVectors->data[j];
     1031            xVec->data.F32[i] = vect->data.F32[j];
     1032        }
    10381033    }
    10391034
    … …  
    10411036
    10421037    kapa = psAlloc(nKapa*sizeof(int));
    1043    
     1038
    10441039    for (int i = 0; i < nKapa; i++) {
    1045         kapa[i] = -1;
    1046         pmVisualInitWindow(&kapa[i], "ppmerge");
     1040        kapa[i] = -1;
     1041        pmVisualInitWindow(&kapa[i], "ppmerge");
    10471042    }
    10481043    return true;
    … …  
    10631058
    10641059    for (int i = 0; i < xVectors->n; i++) {
    1065         psVector *x = xVectors->data[i];
    1066 
    1067         // generate vectors of the unmasked values
    1068         int nSub = 0;
    1069         for (int j = 0; j < pixels->n; j++) {
    1070             if (mask && mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) continue;
    1071             xSub->data.F32[nSub] = x->data.F32[j];
    1072             ySub->data.F32[nSub] = pixels->data.F32[j];
    1073             nSub ++;
    1074         }
    1075         xSub->n = ySub->n = nSub;
    1076        
    1077         // plot the unmasked values
    1078         pmVisualScaleGraphdata (&graphdata, xSub, ySub, false);
    1079         KapaSetGraphData(kapa[i], &graphdata);
    1080         KapaSetLimits(kapa[i], &graphdata);
    1081         KapaClearPlots (kapa[i]);
    1082 
    1083         KapaSetFont (kapa[i], "courier", 14);
    1084         KapaBox (kapa[i], &graphdata);
    1085         KapaSendLabel (kapa[i], "ordinate", KAPA_LABEL_XM);
    1086         KapaSendLabel (kapa[i], "pixel values", KAPA_LABEL_YM);
    1087 
    1088         graphdata.color = KapaColorByName("black");
    1089         graphdata.style = 2;
    1090         graphdata.ptype = 2;
    1091         KapaPrepPlot  (kapa[i], xSub->n, &graphdata);
    1092         KapaPlotVector(kapa[i], xSub->n, xSub->data.F32, "x");
    1093         KapaPlotVector(kapa[i], xSub->n, ySub->data.F32, "y");
     1060        psVector *x = xVectors->data[i];
     1061
     1062        // generate vectors of the unmasked values
     1063        int nSub = 0;
     1064        for (int j = 0; j < pixels->n; j++) {
     1065            if (mask && mask->data.PS_TYPE_VECTOR_MASK_DATA[j]) continue;
     1066            xSub->data.F32[nSub] = x->data.F32[j];
     1067            ySub->data.F32[nSub] = pixels->data.F32[j];
     1068            nSub ++;
     1069        }
     1070        xSub->n = ySub->n = nSub;
     1071
     1072        // plot the unmasked values
     1073        pmVisualScaleGraphdata (&graphdata, xSub, ySub, false);
     1074        KapaSetGraphData(kapa[i], &graphdata);
     1075        KapaSetLimits(kapa[i], &graphdata);
     1076        KapaClearPlots (kapa[i]);
     1077
     1078        KapaSetFont (kapa[i], "courier", 14);
     1079        KapaBox (kapa[i], &graphdata);
     1080        KapaSendLabel (kapa[i], "ordinate", KAPA_LABEL_XM);
     1081        KapaSendLabel (kapa[i], "pixel values", KAPA_LABEL_YM);
     1082
     1083        graphdata.color = KapaColorByName("black");
     1084        graphdata.style = 2;
     1085        graphdata.ptype = 2;
     1086        KapaPrepPlot  (kapa[i], xSub->n, &graphdata);
     1087        KapaPlotVector(kapa[i], xSub->n, xSub->data.F32, "x");
     1088        KapaPlotVector(kapa[i], xSub->n, ySub->data.F32, "y");
    10941089    }
    10951090    pmVisualAskUser (&plotFlag);
    … …  
    11101105
    11111106    for (int i = 0; i < values->n; i++) {
    1112         psVector *coord = values->data[i];
    1113         yFit->data.F32[i] = psPolynomialMDEval (poly, coord);
     1107        psVector *coord = values->data[i];
     1108        yFit->data.F32[i] = psPolynomialMDEval (poly, coord);
    11141109    }
    11151110
    11161111    for (int i = 0; i < xVectors->n; i++) {
    1117         psVector *xFit = xVectors->data[i];
    1118 
    1119         KapaGetGraphData(kapa[i], &graphdata);
    1120         graphdata.color = KapaColorByName("red");
    1121         graphdata.style = 2;
    1122         graphdata.ptype = 7;
    1123         KapaPrepPlot  (kapa[i], xFit->n, &graphdata);
    1124         KapaPlotVector(kapa[i], xFit->n, xFit->data.F32, "x");
    1125         KapaPlotVector(kapa[i], xFit->n, yFit->data.F32, "y");
     1112        psVector *xFit = xVectors->data[i];
     1113
     1114        KapaGetGraphData(kapa[i], &graphdata);
     1115        graphdata.color = KapaColorByName("red");
     1116        graphdata.style = 2;
     1117        graphdata.ptype = 7;
     1118        KapaPrepPlot  (kapa[i], xFit->n, &graphdata);
     1119        KapaPlotVector(kapa[i], xFit->n, xFit->data.F32, "x");
     1120        KapaPlotVector(kapa[i], xFit->n, yFit->data.F32, "y");
    11261121    }
    11271122    pmVisualAskUser (&plotFlag);
    … …  
    11321127
    11331128    for (int i = 0; i < nKapa; i++) {
    1134         KapaClose(kapa[i]);
     1129        KapaClose(kapa[i]);
    11351130    }
    11361131    psFree (kapa);
Note: See TracChangeset for help on using the changeset viewer.