Date: 2016-07-24T16:46:55+00:00

Actual source code: hists.c
petsc-3.7.3 2016-07-24
Report Typos and Errors

      2: /*
      3:   Contains the data structure for plotting a histogram in a window with an axis.
      4: */
      5: #include <petscdraw.h>         /*I "petscdraw.h" I*/
      6: #include <petsc/private/petscimpl.h>         /*I "petscsys.h" I*/
      7: #include <petscviewer.h>         /*I "petscviewer.h" I*/

      9: PetscClassId PETSC_DRAWHG_CLASSID = 0;

     11: struct _p_PetscDrawHG {
     12:   PETSCHEADER(int);
     13:   PetscErrorCode (*destroy)(PetscDrawSP);
     14:   PetscErrorCode (*view)(PetscDrawSP,PetscViewer);
     15:   PetscDraw      win;
     16:   PetscDrawAxis  axis;
     17:   PetscReal      xmin,xmax;
     18:   PetscReal      ymin,ymax;
     19:   int            numBins;
     20:   int            maxBins;
     21:   PetscReal      *bins;
     22:   int            numValues;
     23:   int            maxValues;
     24:   PetscReal      *values;
     25:   int            color;
     26:   PetscBool      calcStats;
     27:   PetscBool      integerBins;
     28: };

     30: #define CHUNKSIZE 100

     34: /*@C
     35:    PetscDrawHGCreate - Creates a histogram data structure.

     37:    Collective on PetscDraw

     39:    Input Parameters:
     40: +  draw  - The window where the graph will be made
     41: -  bins - The number of bins to use

     43:    Output Parameters:
     44: .  hist - The histogram context

     46:    Level: intermediate

     48:    Concepts: histogram^creating

     50: .seealso: PetscDrawHGDestroy()

     52: @*/
     53: PetscErrorCode  PetscDrawHGCreate(PetscDraw draw,int bins,PetscDrawHG *hist)
     54: {
     55:   PetscDrawHG    h;

     63:   PetscHeaderCreate(h,PETSC_DRAWHG_CLASSID,"DrawHG","Histogram","Draw",PetscObjectComm((PetscObject)draw),PetscDrawHGDestroy,NULL);
     64:   PetscLogObjectParent((PetscObject)draw,(PetscObject)h);

     66:   PetscObjectReference((PetscObject)draw);
     67:   h->win = draw;

     69:   h->view        = NULL;
     70:   h->destroy     = NULL;
     71:   h->color       = PETSC_DRAW_GREEN;
     72:   h->xmin        = PETSC_MAX_REAL;
     73:   h->xmax        = PETSC_MIN_REAL;
     74:   h->ymin        = 0.;
     75:   h->ymax        = 1.;
     76:   h->numBins     = bins;
     77:   h->maxBins     = bins;

     79:   PetscMalloc1(h->maxBins,&h->bins);

     81:   h->numValues   = 0;
     82:   h->maxValues   = CHUNKSIZE;
     83:   h->calcStats   = PETSC_FALSE;
     84:   h->integerBins = PETSC_FALSE;

     86:   PetscMalloc1(h->maxValues,&h->values);
     87:   PetscLogObjectMemory((PetscObject)h,(h->maxBins + h->maxValues)*sizeof(PetscReal));

     89:   PetscDrawAxisCreate(draw,&h->axis);
     90:   PetscLogObjectParent((PetscObject)h,(PetscObject)h->axis);

     92:   *hist = h;
     93:   return(0);
     94: }

     98: /*@
     99:    PetscDrawHGSetNumberBins - Change the number of bins that are to be drawn.

    101:    Logically Collective on PetscDrawHG

    103:    Input Parameter:
    104: +  hist - The histogram context.
    105: -  bins  - The number of bins.

    107:    Level: intermediate

    109:    Concepts: histogram^setting number of bins

    111: @*/
    112: PetscErrorCode  PetscDrawHGSetNumberBins(PetscDrawHG hist, int bins)
    113: {

    120:   if (hist->maxBins < bins) {
    121:     PetscFree(hist->bins);
    122:     PetscMalloc1(bins, &hist->bins);
    123:     PetscLogObjectMemory((PetscObject)hist, (bins - hist->maxBins) * sizeof(PetscReal));
    124:     hist->maxBins = bins;
    125:   }
    126:   hist->numBins = bins;
    127:   return(0);
    128: }

    132: /*@
    133:   PetscDrawHGReset - Clears histogram to allow for reuse with new data.

    135:   Logically Collective on PetscDrawHG

    137:   Input Parameter:
    138: . hist - The histogram context.

    140:   Level: intermediate

    142:   Concepts: histogram^resetting
    143: @*/
    144: PetscErrorCode  PetscDrawHGReset(PetscDrawHG hist)
    145: {

    149:   hist->xmin      = PETSC_MAX_REAL;
    150:   hist->xmax      = PETSC_MIN_REAL;
    151:   hist->ymin      = 0.0;
    152:   hist->ymax      = 0.0;
    153:   hist->numValues = 0;
    154:   return(0);
    155: }

    159: /*@C
    160:   PetscDrawHGDestroy - Frees all space taken up by histogram data structure.

    162:   Collective on PetscDrawHG

    164:   Input Parameter:
    165: . hist - The histogram context

    167:   Level: intermediate

    169: .seealso:  PetscDrawHGCreate()
    170: @*/
    171: PetscErrorCode  PetscDrawHGDestroy(PetscDrawHG *hist)
    172: {

    176:   if (!*hist) return(0);
    178:   if (--((PetscObject)(*hist))->refct > 0) {*hist = NULL; return(0);}

    180:   PetscFree((*hist)->bins);
    181:   PetscFree((*hist)->values);
    182:   PetscDrawAxisDestroy(&(*hist)->axis);
    183:   PetscDrawDestroy(&(*hist)->win);
    184:   PetscHeaderDestroy(hist);
    185:   return(0);
    186: }

    190: /*@
    191:   PetscDrawHGAddValue - Adds another value to the histogram.

    193:   Logically Collective on PetscDrawHG

    195:   Input Parameters:
    196: + hist  - The histogram
    197: - value - The value

    199:   Level: intermediate

    201:   Concepts: histogram^adding values

    203: .seealso: PetscDrawHGAddValues()
    204: @*/
    205: PetscErrorCode  PetscDrawHGAddValue(PetscDrawHG hist, PetscReal value)
    206: {

    210:   /* Allocate more memory if necessary */
    211:   if (hist->numValues >= hist->maxValues) {
    212:     PetscReal      *tmp;

    215:     PetscMalloc1(hist->maxValues+CHUNKSIZE, &tmp);
    216:     PetscLogObjectMemory((PetscObject)hist, CHUNKSIZE * sizeof(PetscReal));
    217:     PetscMemcpy(tmp, hist->values, hist->maxValues * sizeof(PetscReal));
    218:     PetscFree(hist->values);

    220:     hist->values     = tmp;
    221:     hist->maxValues += CHUNKSIZE;
    222:   }
    223:   /* I disagree with the original Petsc implementation here. There should be no overshoot, but rather the
    224:      stated convention of using half-open intervals (always the way to go) */
    225:   if (!hist->numValues) {
    226:     hist->xmin = value;
    227:     hist->xmax = value;
    228: #if 1
    229:   } else {
    230:     /* Update limits */
    231:     if (value > hist->xmax) hist->xmax = value;
    232:     if (value < hist->xmin) hist->xmin = value;
    233: #else
    234:   } else if (hist->numValues == 1) {
    235:     /* Update limits -- We need to overshoot the largest value somewhat */
    236:     if (value > hist->xmax) hist->xmax = value + 0.001*(value - hist->xmin)/hist->numBins;
    237:     if (value < hist->xmin) {
    238:       hist->xmin = value;
    239:       hist->xmax = hist->xmax + 0.001*(hist->xmax - hist->xmin)/hist->numBins;
    240:     }
    241:   } else {
    242:     /* Update limits -- We need to overshoot the largest value somewhat */
    243:     if (value > hist->xmax) hist->xmax = value + 0.001*(hist->xmax - hist->xmin)/hist->numBins;
    244:     if (value < hist->xmin) hist->xmin = value;
    245: #endif
    246:   }

    248:   hist->values[hist->numValues++] = value;
    249:   return(0);
    250: }

    254: /*@
    255:   PetscDrawHGDraw - Redraws a histogram.

    257:   Collective on PetscDrawHG

    259:   Input Parameter:
    260: . hist - The histogram context

    262:   Level: intermediate

    264: @*/
    265: PetscErrorCode  PetscDrawHGDraw(PetscDrawHG hist)
    266: {
    267:   PetscDraw      draw;
    268:   PetscBool      isnull;
    269:   PetscReal      xmin,xmax,ymin,ymax,*bins,*values,binSize,binLeft,binRight,maxHeight,mean,var;
    270:   char           title[256];
    271:   char           xlabel[256];
    272:   PetscInt       numBins,numBinsOld,numValues,initSize,i,p,bcolor,color;
    273:   PetscMPIInt    rank;

    278:   PetscDrawIsNull(hist->win,&isnull);
    279:   if (isnull) return(0);
    280:   MPI_Comm_rank(PetscObjectComm((PetscObject)hist),&rank);

    282:   if ((hist->xmin >= hist->xmax) || (hist->ymin >= hist->ymax)) return(0);
    283:   if (hist->numValues < 1) return(0);

    285:   color = hist->color;
    286:   if (color == PETSC_DRAW_ROTATE) bcolor = PETSC_DRAW_BLACK+1;
    287:   else bcolor = color;

    289:   xmin      = hist->xmin;
    290:   xmax      = hist->xmax;
    291:   ymin      = hist->ymin;
    292:   ymax      = hist->ymax;
    293:   numValues = hist->numValues;
    294:   values    = hist->values;
    295:   mean      = 0.0;
    296:   var       = 0.0;

    298:   draw = hist->win;
    299:   PetscDrawCheckResizedWindow(draw);
    300:   PetscDrawClear(draw);

    302:   if (xmin == xmax) {
    303:     /* Calculate number of points in each bin */
    304:     bins    = hist->bins;
    305:     bins[0] = 0.;
    306:     for (p = 0; p < numValues; p++) {
    307:       if (values[p] == xmin) bins[0]++;
    308:       mean += values[p];
    309:       var  += values[p]*values[p];
    310:     }
    311:     maxHeight = bins[0];
    312:     if (maxHeight > ymax) ymax = hist->ymax = maxHeight;
    313:     xmax = xmin + 1;
    314:     PetscDrawAxisSetLimits(hist->axis, xmin, xmax, ymin, ymax);
    315:     if (hist->calcStats) {
    316:       mean /= numValues;
    317:       if (numValues > 1) var = (var - numValues*mean*mean) / (numValues-1);
    318:       else var = 0.0;
    319:       PetscSNPrintf(title, 256, "Mean: %g  Var: %g", (double)mean, (double)var);
    320:       PetscSNPrintf(xlabel,256, "Total: %D", numValues);
    321:       PetscDrawAxisSetLabels(hist->axis, title, xlabel, NULL);
    322:     }
    323:     PetscDrawAxisDraw(hist->axis);
    324:     PetscDrawCollectiveBegin(draw);
    325:     if (!rank) { /* Draw bins */
    326:       binLeft  = xmin;
    327:       binRight = xmax;
    328:       PetscDrawRectangle(draw,binLeft,ymin,binRight,bins[0],bcolor,bcolor,bcolor,bcolor);
    329:       PetscDrawLine(draw,binLeft,ymin,binLeft,bins[0],PETSC_DRAW_BLACK);
    330:       PetscDrawLine(draw,binRight,ymin,binRight,bins[0],PETSC_DRAW_BLACK);
    331:       PetscDrawLine(draw,binLeft,bins[0],binRight,bins[0],PETSC_DRAW_BLACK);
    332:     }
    333:     PetscDrawCollectiveEnd(draw);
    334:   } else {
    335:     numBins    = hist->numBins;
    336:     numBinsOld = hist->numBins;
    337:     if (hist->integerBins && (((int) xmax - xmin) + 1.0e-05 > xmax - xmin)) {
    338:       initSize = (int) ((int) xmax - xmin)/numBins;
    339:       while (initSize*numBins != (int) xmax - xmin) {
    340:         initSize = PetscMax(initSize - 1, 1);
    341:         numBins  = (int) ((int) xmax - xmin)/initSize;
    342:         PetscDrawHGSetNumberBins(hist, numBins);
    343:       }
    344:     }
    345:     binSize = (xmax - xmin)/numBins;
    346:     bins    = hist->bins;

    348:     PetscMemzero(bins, numBins * sizeof(PetscReal));

    350:     maxHeight = 0.0;
    351:     for (i = 0; i < numBins; i++) {
    352:       binLeft  = xmin + binSize*i;
    353:       binRight = xmin + binSize*(i+1);
    354:       for (p = 0; p < numValues; p++) {
    355:         if ((values[p] >= binLeft) && (values[p] < binRight)) bins[i]++;
    356:         /* Handle last bin separately */
    357:         if ((i == numBins-1) && (values[p] == binRight)) bins[i]++;
    358:         if (!i) {
    359:           mean += values[p];
    360:           var  += values[p]*values[p];
    361:         }
    362:       }
    363:       maxHeight = PetscMax(maxHeight, bins[i]);
    364:     }
    365:     if (maxHeight > ymax) ymax = hist->ymax = maxHeight;

    367:     PetscDrawAxisSetLimits(hist->axis, xmin, xmax, ymin, ymax);
    368:     if (hist->calcStats) {
    369:       mean /= numValues;
    370:       if (numValues > 1) var = (var - numValues*mean*mean) / (numValues-1);
    371:       else var = 0.0;
    372:       PetscSNPrintf(title, 256,"Mean: %g  Var: %g", (double)mean, (double)var);
    373:       PetscSNPrintf(xlabel,256, "Total: %D", numValues);
    374:       PetscDrawAxisSetLabels(hist->axis, title, xlabel, NULL);
    375:     }
    376:     PetscDrawAxisDraw(hist->axis);
    377:     PetscDrawCollectiveBegin(draw);
    378:     if (!rank) { /* Draw bins */
    379:       for (i = 0; i < numBins; i++) {
    380:         binLeft  = xmin + binSize*i;
    381:         binRight = xmin + binSize*(i+1);
    382:         PetscDrawRectangle(draw,binLeft,ymin,binRight,bins[i],bcolor,bcolor,bcolor,bcolor);
    383:         PetscDrawLine(draw,binLeft,ymin,binLeft,bins[i],PETSC_DRAW_BLACK);
    384:         PetscDrawLine(draw,binRight,ymin,binRight,bins[i],PETSC_DRAW_BLACK);
    385:         PetscDrawLine(draw,binLeft,bins[i],binRight,bins[i],PETSC_DRAW_BLACK);
    386:         if (color == PETSC_DRAW_ROTATE && bins[i]) bcolor++;
    387:         if (bcolor > PETSC_DRAW_BASIC_COLORS-1) bcolor = PETSC_DRAW_BLACK+1;
    388:       }
    389:     }
    390:     PetscDrawCollectiveEnd(draw);
    391:     PetscDrawHGSetNumberBins(hist,numBinsOld);
    392:   }

    394:   PetscDrawFlush(draw);
    395:   PetscDrawPause(draw);
    396:   return(0);
    397: }

    401: /*@
    402:   PetscDrawHGSave - Saves a drawn image

    404:   Collective on PetscDrawHG

    406:   Input Parameter:
    407: . hist - The histogram context

    409:   Level: intermediate

    411:   Concepts: histogram^saving

    413: .seealso:  PetscDrawHGCreate(), PetscDrawHGGetDraw(), PetscDrawSetSave(), PetscDrawSave()
    414: @*/
    415: PetscErrorCode  PetscDrawHGSave(PetscDrawHG hg)
    416: {

    421:   PetscDrawSave(hg->win);
    422:   return(0);
    423: }

    427: /*@
    428:   PetscDrawHGView - Prints the histogram information.

    430:   Not collective

    432:   Input Parameter:
    433: . hist - The histogram context

    435:   Level: beginner

    437: .keywords:  draw, histogram
    438: @*/
    439: PetscErrorCode  PetscDrawHGView(PetscDrawHG hist,PetscViewer viewer)
    440: {
    441:   PetscReal      xmax,xmin,*bins,*values,binSize,binLeft,binRight,mean,var;
    443:   PetscInt       numBins,numBinsOld,numValues,initSize,i,p;

    448:   if ((hist->xmin > hist->xmax) || (hist->ymin >= hist->ymax)) return(0);
    449:   if (hist->numValues < 1) return(0);

    451:   if (!viewer){
    452:     PetscViewerASCIIGetStdout(PetscObjectComm((PetscObject)hist),&viewer);
    453:   }
    454:   PetscObjectPrintClassNamePrefixType((PetscObject)hist,viewer);
    455:   xmax      = hist->xmax;
    456:   xmin      = hist->xmin;
    457:   numValues = hist->numValues;
    458:   values    = hist->values;
    459:   mean      = 0.0;
    460:   var       = 0.0;
    461:   if (xmax == xmin) {
    462:     /* Calculate number of points in the bin */
    463:     bins    = hist->bins;
    464:     bins[0] = 0.;
    465:     for (p = 0; p < numValues; p++) {
    466:       if (values[p] == xmin) bins[0]++;
    467:       mean += values[p];
    468:       var  += values[p]*values[p];
    469:     }
    470:     /* Draw bins */
    471:     PetscViewerASCIIPrintf(viewer, "Bin %2d (%6.2g - %6.2g): %.0g\n", 0, (double)xmin, (double)xmax, (double)bins[0]);
    472:   } else {
    473:     numBins    = hist->numBins;
    474:     numBinsOld = hist->numBins;
    475:     if (hist->integerBins && (((int) xmax - xmin) + 1.0e-05 > xmax - xmin)) {
    476:       initSize = (int) ((int) xmax - xmin)/numBins;
    477:       while (initSize*numBins != (int) xmax - xmin) {
    478:         initSize = PetscMax(initSize - 1, 1);
    479:         numBins  = (int) ((int) xmax - xmin)/initSize;
    480:         PetscDrawHGSetNumberBins(hist, numBins);
    481:       }
    482:     }
    483:     binSize = (xmax - xmin)/numBins;
    484:     bins    = hist->bins;

    486:     /* Calculate number of points in each bin */
    487:     PetscMemzero(bins, numBins * sizeof(PetscReal));
    488:     for (i = 0; i < numBins; i++) {
    489:       binLeft  = xmin + binSize*i;
    490:       binRight = xmin + binSize*(i+1);
    491:       for (p = 0; p < numValues; p++) {
    492:         if ((values[p] >= binLeft) && (values[p] < binRight)) bins[i]++;
    493:         /* Handle last bin separately */
    494:         if ((i == numBins-1) && (values[p] == binRight)) bins[i]++;
    495:         if (!i) {
    496:           mean += values[p];
    497:           var  += values[p]*values[p];
    498:         }
    499:       }
    500:     }
    501:     /* Draw bins */
    502:     for (i = 0; i < numBins; i++) {
    503:       binLeft  = xmin + binSize*i;
    504:       binRight = xmin + binSize*(i+1);
    505:       PetscViewerASCIIPrintf(viewer, "Bin %2d (%6.2g - %6.2g): %.0g\n", (int)i, (double)binLeft, (double)binRight, (double)bins[i]);
    506:     }
    507:     PetscDrawHGSetNumberBins(hist, numBinsOld);
    508:   }

    510:   if (hist->calcStats) {
    511:     mean /= numValues;
    512:     if (numValues > 1) var = (var - numValues*mean*mean) / (numValues-1);
    513:     else var = 0.0;
    514:     PetscViewerASCIIPrintf(viewer, "Mean: %g  Var: %g\n", (double)mean, (double)var);
    515:     PetscViewerASCIIPrintf(viewer, "Total: %D\n", numValues);
    516:   }
    517:   return(0);
    518: }

    522: /*@
    523:   PetscDrawHGSetColor - Sets the color the bars will be drawn with.

    525:   Logically Collective on PetscDrawHG

    527:   Input Parameters:
    528: + hist - The histogram context
    529: - color - one of the colors defined in petscdraw.h or PETSC_DRAW_ROTATE to make each bar a
    530:           different color

    532:   Level: intermediate

    534: @*/
    535: PetscErrorCode  PetscDrawHGSetColor(PetscDrawHG hist,int color)
    536: {

    540:   hist->color = color;
    541:   return(0);
    542: }

    546: /*@
    547:   PetscDrawHGSetLimits - Sets the axis limits for a histogram. If more
    548:   points are added after this call, the limits will be adjusted to
    549:   include those additional points.

    551:   Logically Collective on PetscDrawHG

    553:   Input Parameters:
    554: + hist - The histogram context
    555: - x_min,x_max,y_min,y_max - The limits

    557:   Level: intermediate

    559:   Concepts: histogram^setting axis
    560: @*/
    561: PetscErrorCode  PetscDrawHGSetLimits(PetscDrawHG hist, PetscReal x_min, PetscReal x_max, int y_min, int y_max)
    562: {

    566:   hist->xmin = x_min;
    567:   hist->xmax = x_max;
    568:   hist->ymin = y_min;
    569:   hist->ymax = y_max;
    570:   return(0);
    571: }

    575: /*@
    576:   PetscDrawHGCalcStats - Turns on calculation of descriptive statistics

    578:   Not collective

    580:   Input Parameters:
    581: + hist - The histogram context
    582: - calc - Flag for calculation

    584:   Level: intermediate

    586: .keywords:  draw, histogram, statistics

    588: @*/
    589: PetscErrorCode  PetscDrawHGCalcStats(PetscDrawHG hist, PetscBool calc)
    590: {

    594:   hist->calcStats = calc;
    595:   return(0);
    596: }

    600: /*@
    601:   PetscDrawHGIntegerBins - Turns on integer width bins

    603:   Not collective

    605:   Input Parameters:
    606: + hist - The histogram context
    607: - ints - Flag for integer width bins

    609:   Level: intermediate

    611: .keywords:  draw, histogram, statistics
    612: @*/
    613: PetscErrorCode  PetscDrawHGIntegerBins(PetscDrawHG hist, PetscBool ints)
    614: {

    618:   hist->integerBins = ints;
    619:   return(0);
    620: }

    624: /*@C
    625:   PetscDrawHGGetAxis - Gets the axis context associated with a histogram.
    626:   This is useful if one wants to change some axis property, such as
    627:   labels, color, etc. The axis context should not be destroyed by the
    628:   application code.

    630:   Not Collective, PetscDrawAxis is parallel if PetscDrawHG is parallel

    632:   Input Parameter:
    633: . hist - The histogram context

    635:   Output Parameter:
    636: . axis - The axis context

    638:   Level: intermediate

    640: @*/
    641: PetscErrorCode  PetscDrawHGGetAxis(PetscDrawHG hist,PetscDrawAxis *axis)
    642: {
    646:   *axis = hist->axis;
    647:   return(0);
    648: }

    652: /*@C
    653:   PetscDrawHGGetDraw - Gets the draw context associated with a histogram.

    655:   Not Collective, PetscDraw is parallel if PetscDrawHG is parallel

    657:   Input Parameter:
    658: . hist - The histogram context

    660:   Output Parameter:
    661: . draw  - The draw context

    663:   Level: intermediate

    665: @*/
    666: PetscErrorCode  PetscDrawHGGetDraw(PetscDrawHG hist,PetscDraw *draw)
    667: {
    671:   *draw = hist->win;
    672:   return(0);
    673: }