sddseventhist.c File Reference

Generates histograms for events from SDDS input files. More...

#include "mdb.h"
#include "scan.h"
#include "SDDS.h"

Go to the source code of this file.

Classes
struct	EVENT_DATA
struct	EVENT_PAIR

Macros
#define	NORMALIZE_PEAK   0
#define	NORMALIZE_AREA   1
#define	NORMALIZE_SUM   2
#define	NORMALIZE_NO   3
#define	N_NORMALIZE_OPTIONS   4

Enumerations
enum	option_type {   SET_BINS , SET_LOWERLIMIT , SET_UPPERLIMIT , SET_DATACOLUMN ,   SET_BINSIZE , SET_NORMALIZE , SET_SIDES , SET_PIPE ,   SET_EVENTIDENTIFIER , SET_OVERLAPEVENT , SET_MAJOR_ORDER , N_OPTIONS }

Functions
static long	setupOutputFile (SDDS_DATASET *outTable, char *outputfile, SDDS_DATASET *inTable, char *inputfile, char *dataColumn, char *eventIDColumn, char *overlapEventID, EVENT_DATA **eventDataRet, int64_t *eventIDsRet, double **dataRet, long bins, double binSize, long normalizeMode, short columnMajorOrder)
long	makeEventHistogram (double *hist, long bins, double lowerLimit, double dx, EVENT_DATA *eventRefData)
void	makeEventOverlap (double *overlap, double *hist, double *overlapHist, long bins)
int	event_cmpasc (const void *ep1, const void *ep2)
int	main (int argc, char **argv)

Variables
char *	option [N_OPTIONS]
char *	USAGE
static char *	additional_help
char *	normalize_option [N_NORMALIZE_OPTIONS]

Detailed Description

Generates histograms for events from SDDS input files.

This program reads an SDDS input file, processes the specified data column, and generates histograms for each unique event identifier. It supports various options for binning, normalization, and output formatting. Additionally, it can handle overlapping events by multiplying histograms bin-by-bin with a reference event histogram.

Usage

sddseventhist [<inputfile>] [<outputfile>]
             [-pipe=<input>,<output>]
             -dataColumn=<columnName>
             -eventIdentifier=<columnName>
             [-overlapEvent=<eventValue>]
             [{-bins=<number> | -sizeOfBins=<value>}]
             [-lowerLimit=<value>]
             [-upperLimit=<value>]
             [-sides]
             [-normalize[={sum|area|peak}]]
             [-majorOrder=row|column]

Options

• -pipe=<input>,<output>: Use pipe for input and/or output.
• -dataColumn=<columnName>: Specify the name of the column to histogram.
• -eventIdentifier=<columnName>: Specify the column used to identify events.
• -overlapEvent=<eventValue>: If given, histograms are multiplied with this event's histogram.
• -bins=<number>: Number of bins for the histogram.
• -sizeOfBins=<value>: Size of each bin.
• -lowerLimit=<value>: Lower limit of the histogram.
• -upperLimit=<value>: Upper limit of the histogram.
• -sides: Adds sides to the histogram down to the zero level.
• -normalize[={sum|area|peak}]: Normalize the histogram by sum, area, or peak.
• -majorOrder=row|column: Specify the major order for output file.

Copyright

• (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
• (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.

License

This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.

Author

M. Borland, R. Soliday, Xuesong Jiao, H. Shang

Definition in file sddseventhist.c.

Macro Definition Documentation

N_NORMALIZE_OPTIONS

#define N_NORMALIZE_OPTIONS   4

Definition at line 118 of file sddseventhist.c.

NORMALIZE_AREA

#define NORMALIZE_AREA   1

Definition at line 115 of file sddseventhist.c.

NORMALIZE_NO

#define NORMALIZE_NO   3

Definition at line 117 of file sddseventhist.c.

NORMALIZE_PEAK

#define NORMALIZE_PEAK   0

Definition at line 114 of file sddseventhist.c.

NORMALIZE_SUM

#define NORMALIZE_SUM   2

Definition at line 116 of file sddseventhist.c.

Enumeration Type Documentation

option_type

enum option_type

Definition at line 55 of file sddseventhist.c.

                 {
  SET_BINS,
  SET_LOWERLIMIT,
  SET_UPPERLIMIT,
  SET_DATACOLUMN,
  SET_BINSIZE,
  SET_NORMALIZE,
  SET_SIDES,
  SET_PIPE,
  SET_EVENTIDENTIFIER,
  SET_OVERLAPEVENT,
  SET_MAJOR_ORDER,
  N_OPTIONS
};

Function Documentation

event_cmpasc()

int event_cmpasc	(	const void *	ep1,
		const void *	ep2 )

Definition at line 598 of file sddseventhist.c.

                                                   {
  EVENT_PAIR *ev1, *ev2;
  int comp;
  ev1 = (EVENT_PAIR *)ep1;
  ev2 = (EVENT_PAIR *)ep2;
  if ((comp = strcmp(ev1->string, ev2->string)) != 0)
    return comp;
  if (ev1->data < ev2->data)
    return -1;
  else if (ev1->data > ev2->data)
    return 1;
  else
    return 0;
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 146 of file sddseventhist.c.

                                {
  /* Flags to keep track of what is set in command line */
  long binsGiven, lowerLimitGiven, upperLimitGiven;
  SDDS_DATASET inTable, outTable;
  double *data;  /* Pointer to the array to histogram */
  double *hist;  /* To store the histogram */
  double *indep; /* To store values of bin centers */
  double *overlap, *overlapHist;
  double lowerLimit, upperLimit;           /* Lower and upper limits in histogram */
  double givenLowerLimit, givenUpperLimit; /* Given lower and upper limits */
  double range, binSize;
  long bins; /* Number of bins in the histogram */
  char *dataColumn, *eventIDColumn, *overlapEventID;
  SCANNED_ARG *scanned;         /* Scanned argument structure */
  char *inputfile, *outputfile; /* Input and output file names */
  double dx;                    /* Spacing of bins in histogram */
  long pointsBinned;            /* Number of points that are in histogram */
  long normalizeMode, doSides, verbose = 0, readCode;
  unsigned long pipeFlags, majorOrderFlag;
  long eventIDIndex, eventIDType;
  int64_t eventRefIDs = 0;
  EVENT_DATA *eventRefData = NULL;
  /*char **eventID; */
  int64_t i, points, iEvent;
  short columnMajorOrder = -1;
 
  SDDS_RegisterProgramName(argv[0]);
 
  argc = scanargs(&scanned, argc, argv);
  if (argc < 3) {
    fprintf(stderr, "Usage: %s\n", USAGE);
    fputs(additional_help, stderr);
    exit(EXIT_FAILURE);
  }
 
  hist = overlap = overlapHist = NULL;
  binsGiven = lowerLimitGiven = upperLimitGiven = 0;
  binSize = doSides = 0;
  inputfile = outputfile = NULL;
  dataColumn = eventIDColumn = overlapEventID = NULL;
  normalizeMode = NORMALIZE_NO;
  pipeFlags = 0;
 
  for (i = 1; i < argc; i++) {
    if (scanned[i].arg_type == OPTION) {
      switch (match_string(scanned[i].list[0], option, N_OPTIONS, 0)) {
      case SET_MAJOR_ORDER:
        majorOrderFlag = 0;
        scanned[i].n_items--;
        if (scanned[i].n_items > 0 && (!scanItemList(&majorOrderFlag, scanned[i].list + 1, &scanned[i].n_items, 0, "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER, "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL)))
          SDDS_Bomb("invalid -majorOrder syntax/values");
        if (majorOrderFlag & SDDS_COLUMN_MAJOR_ORDER)
          columnMajorOrder = 1;
        else if (majorOrderFlag & SDDS_ROW_MAJOR_ORDER)
          columnMajorOrder = 0;
        break;
      case SET_BINS: /* set number of bins */
        if (binsGiven)
          SDDS_Bomb("-bins specified more than once");
        binsGiven = 1;
        if (sscanf(scanned[i].list[1], "%ld", &bins) != 1 || bins <= 0)
          SDDS_Bomb("invalid value for bins");
        break;
      case SET_LOWERLIMIT:
        if (lowerLimitGiven)
          SDDS_Bomb("-lowerLimit specified more than once");
        lowerLimitGiven = 1;
        if (sscanf(scanned[i].list[1], "%lf", &givenLowerLimit) != 1)
          SDDS_Bomb("invalid value for lowerLimit");
        break;
      case SET_UPPERLIMIT:
        if (upperLimitGiven)
          SDDS_Bomb("-upperLimit specified more than once");
        upperLimitGiven = 1;
        if (sscanf(scanned[i].list[1], "%lf", &givenUpperLimit) != 1)
          SDDS_Bomb("invalid value for upperLimit");
        break;
      case SET_DATACOLUMN:
        if (dataColumn)
          SDDS_Bomb("-dataColumn specified more than once");
        if (scanned[i].n_items != 2)
          SDDS_Bomb("invalid -dataColumn syntax---supply name");
        dataColumn = scanned[i].list[1];
        break;
      case SET_EVENTIDENTIFIER:
        if (eventIDColumn)
          SDDS_Bomb("-eventIdentifier specified more than once");
        if (scanned[i].n_items != 2)
          SDDS_Bomb("invalid -eventIdentifier syntax---supply name");
        eventIDColumn = scanned[i].list[1];
        break;
      case SET_OVERLAPEVENT:
        if (overlapEventID)
          SDDS_Bomb("-overlapEvent specified more than once");
        if (scanned[i].n_items != 2)
          SDDS_Bomb("invalid -overlapEvent syntax---supply value");
        overlapEventID = scanned[i].list[1];
        if (!strlen(overlapEventID))
          SDDS_Bomb("invalid -overlapEvent syntax---supply value");
        break;
      case SET_NORMALIZE:
        if (scanned[i].n_items == 1)
          normalizeMode = NORMALIZE_SUM;
        else if (scanned[i].n_items != 2 || (normalizeMode = match_string(scanned[i].list[1], normalize_option, N_NORMALIZE_OPTIONS, 0)) < 0)
          SDDS_Bomb("invalid -normalize syntax");
        break;
      case SET_SIDES:
        doSides = 1;
        break;
      case SET_BINSIZE:
        if (sscanf(scanned[i].list[1], "%le", &binSize) != 1 || binSize <= 0)
          SDDS_Bomb("invalid value for bin size");
        break;
      case SET_PIPE:
        if (!processPipeOption(scanned[i].list + 1, scanned[i].n_items - 1, &pipeFlags))
          SDDS_Bomb("invalid -pipe syntax");
        break;
      default:
        fprintf(stderr, "Error: option %s not recognized\n", scanned[i].list[0]);
        exit(EXIT_FAILURE);
        break;
      }
    } else {
      /* Argument is filename */
      if (!inputfile)
        inputfile = scanned[i].list[0];
      else if (!outputfile)
        outputfile = scanned[i].list[0];
      else
        SDDS_Bomb("Too many filenames provided.");
    }
  }
 
  processFilenames("sddseventhist", &inputfile, &outputfile, pipeFlags, 0, NULL);
 
  if (binSize && binsGiven)
    SDDS_Bomb("Specify either -binSize or -bins, not both.");
  if (!binsGiven)
    bins = 20;
  if (!dataColumn)
    SDDS_Bomb("-dataColumn must be specified.");
  if (!eventIDColumn)
    SDDS_Bomb("-eventIdentifier must be specified.");
 
  if (!(indep = SDDS_Malloc(sizeof(*indep) * (bins + 2))) ||
      !(hist = SDDS_Malloc(sizeof(*hist) * (bins + 2))) ||
      !(overlap = SDDS_Malloc(sizeof(*overlap) * (bins + 2))) ||
      !(overlapHist = SDDS_Malloc(sizeof(*overlapHist) * (bins + 2))))
    SDDS_Bomb("Memory allocation failure.");
 
  if (!SDDS_InitializeInput(&inTable, inputfile))
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
  if (SDDS_GetColumnIndex(&inTable, dataColumn) < 0)
    SDDS_Bomb("Data column not found.");
  if ((eventIDIndex = SDDS_GetColumnIndex(&inTable, eventIDColumn)) < 0)
    SDDS_Bomb("Event ID column not found.");
  if ((eventIDType = SDDS_GetColumnType(&inTable, eventIDIndex)) != SDDS_STRING)
    SDDS_Bomb("Event ID column must be of string type.");
  if (!SDDS_NUMERIC_TYPE(SDDS_GetNamedColumnType(&inTable, dataColumn)))
    SDDS_Bomb("Data column must be of a numeric data type.");
 
  data = NULL;
  while ((readCode = SDDS_ReadPage(&inTable)) > 0) {
    if (readCode > 1)
      SDDS_Bomb("This program cannot process multi-page files.");
    pointsBinned = 0;
    if ((points = SDDS_CountRowsOfInterest(&inTable)) < 0)
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    if (!points)
      SDDS_Bomb("No data found in the file.");
 
    if (!setupOutputFile(&outTable, outputfile, &inTable, inputfile, dataColumn, eventIDColumn, overlapEventID, &eventRefData, &eventRefIDs, &data, bins, binSize, normalizeMode, columnMajorOrder))
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
    if (!lowerLimitGiven) {
      lowerLimit = 0;
      if (points)
        lowerLimit = data[0];
      for (i = 0; i < points; i++)
        if (lowerLimit > data[i])
          lowerLimit = data[i];
    } else {
      lowerLimit = givenLowerLimit;
    }
 
    if (!upperLimitGiven) {
      upperLimit = 0;
      if (points)
        upperLimit = data[0];
      for (i = 0; i < points; i++)
        if (upperLimit < data[i])
          upperLimit = data[i];
    } else {
      upperLimit = givenUpperLimit;
    }
 
    free(data);
    data = NULL;
    range = upperLimit - lowerLimit;
    if (!lowerLimitGiven)
      lowerLimit -= range * 1e-7;
    if (!upperLimitGiven)
      upperLimit += range * 1e-7;
    if (upperLimit == lowerLimit) {
      if (binSize) {
        upperLimit += binSize / 2;
        lowerLimit -= binSize / 2;
      } else if (fabs(upperLimit) < sqrt(DBL_MIN)) {
        upperLimit = sqrt(DBL_MIN);
        lowerLimit = -sqrt(DBL_MIN);
      } else {
        upperLimit += upperLimit * (1 + 2 * DBL_EPSILON);
        lowerLimit -= upperLimit * (1 - 2 * DBL_EPSILON);
      }
    }
    dx = (upperLimit - lowerLimit) / bins;
 
    if (binSize) {
      double middle;
      range = ((range / binSize) + 1) * binSize;
      middle = (lowerLimit + upperLimit) / 2;
      lowerLimit = middle - range / 2;
      upperLimit = middle + range / 2;
      dx = binSize;
      bins = range / binSize + 0.5;
      if (bins < 1 && !doSides)
        bins = 2;
      if (!(indep = SDDS_Realloc(indep, sizeof(*indep) * (bins + 2))) ||
          !(hist = SDDS_Realloc(hist, sizeof(*hist) * (bins + 2))) ||
          !(overlap = SDDS_Realloc(overlap, sizeof(*overlap) * (bins + 2))) ||
          !(overlapHist = SDDS_Realloc(overlapHist, sizeof(*overlapHist) * (bins + 2))))
        SDDS_Bomb("Memory allocation failure.");
    }
 
    for (i = -1; i < bins + 1; i++) {
      indep[i + 1] = (i + 0.5) * dx + lowerLimit;
    }
    if (!SDDS_StartPage(&outTable, points ? (doSides ? bins + 2 : bins) : 0) ||
        !SDDS_CopyParameters(&outTable, &inTable) ||
        (points && (!SDDS_SetColumnFromDoubles(&outTable, SDDS_SET_BY_NAME, indep + (doSides ? 0 : 1), doSides ? bins + 2 : bins, dataColumn))))
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
    if (overlapEventID) {
      for (iEvent = 0; iEvent < eventRefIDs; iEvent++) {
        if (strcmp(eventRefData[iEvent].string, overlapEventID) == 0)
          break;
      }
      if (iEvent == eventRefIDs)
        SDDS_Bomb("Cannot create overlap as the specified overlap event is not present.");
      makeEventHistogram(overlapHist, bins, lowerLimit, dx, eventRefData + iEvent);
    }
 
    for (iEvent = pointsBinned = 0; iEvent < eventRefIDs; iEvent++) {
      pointsBinned += makeEventHistogram(hist, bins, lowerLimit, dx, eventRefData + iEvent);
      if (normalizeMode != NORMALIZE_NO) {
        double norm = 0;
        switch (normalizeMode) {
        case NORMALIZE_PEAK:
          norm = max_in_array(hist, bins);
          break;
        case NORMALIZE_AREA:
        case NORMALIZE_SUM:
          for (i = 0; i < bins; i++)
            norm += hist[i];
          if (normalizeMode == NORMALIZE_AREA)
            norm *= dx;
          break;
        default:
          SDDS_Bomb("Invalid normalization mode.");
          break;
        }
        if (norm)
          for (i = 0; i < bins; i++)
            hist[i] /= norm;
      }
 
      if (!SDDS_SetColumnFromDoubles(&outTable, SDDS_SET_BY_INDEX, hist + (doSides ? 0 : 1), doSides ? bins + 2 : bins, eventRefData[iEvent].histogramIndex))
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      if (overlapEventID) {
        makeEventOverlap(overlap, hist, overlapHist, bins + 2);
        if (!SDDS_SetColumnFromDoubles(&outTable, SDDS_SET_BY_INDEX, overlap + (doSides ? 0 : 1), doSides ? bins + 2 : bins, eventRefData[iEvent].overlapIndex))
          SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      }
      free(eventRefData[iEvent].data);
    }
 
    if (!SDDS_SetParameters(&outTable, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE,
                            "sddseventhistBins", bins,
                            "sddseventhistBinSize", dx,
                            "sddseventhistPointsBinned", pointsBinned,
                            NULL))
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
    if (verbose)
      fprintf(stderr, "%ld points of %" PRId64 " from page %ld histogrammed in %ld bins\n", pointsBinned, points, readCode, bins);
 
    if (!SDDS_WritePage(&outTable))
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    free(eventRefData);
  }
 
  if (!SDDS_Terminate(&inTable)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
  if (!SDDS_Terminate(&outTable)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
 
  free(hist);
  free(overlapHist);
  free(overlap);
  free(indep);
  return EXIT_SUCCESS;
}

makeEventHistogram()

long makeEventHistogram	(	double *	hist,
		long	bins,
		double	lowerLimit,
		double	dx,
		EVENT_DATA *	eventRefData )

Definition at line 574 of file sddseventhist.c.

                                                                                                         {
  long iBin, pointsBinned;
  int64_t iRow;
  double *hist1;
  hist1 = hist + 1;
  for (iBin = 0; iBin <= bins + 1; iBin++)
    hist[iBin] = 0;
  for (iRow = 0; iRow < eventRefData->events; iRow++) {
    iBin = (eventRefData->data[iRow] - lowerLimit) / dx;
    if (iBin >= 0 && iBin < bins)
      hist1[iBin] += 1;
  }
  for (iBin = pointsBinned = 0; iBin < bins; iBin++)
    pointsBinned += hist1[iBin];
  return pointsBinned;
}

makeEventOverlap()

void makeEventOverlap	(	double *	overlap,
		double *	hist,
		double *	overlapHist,
		long	bins )

Definition at line 591 of file sddseventhist.c.

                                                                                     {
  long i;
  for (i = 0; i < bins; i++) {
    overlap[i] = fmin(hist[i], overlapHist[i]);
  }
}

setupOutputFile()

long setupOutputFile ( SDDS_DATASET * outTable, char * outputfile, SDDS_DATASET * inTable, char * inputfile, char * dataColumn, char * eventIDColumn, char * overlapEventID, EVENT_DATA ** eventDataRet, int64_t * eventIDsRet, double ** dataRet, long bins, double binSize, long normalizeMode, short columnMajorOrder )

static

Definition at line 463 of file sddseventhist.c.

                                                                                 {
  char **eventValue, buffer[SDDS_MAXLINE];
  int64_t eventRows, uniqueRows, row;
  EVENT_DATA *eventData;
  EVENT_PAIR *eventPair;
  double *eventDataValue;
  int64_t row0, iEvent, drow;
 
  if (!SDDS_InitializeOutput(outTable, SDDS_BINARY, 0, NULL, "sddseventhist output", outputfile) ||
      !SDDS_TransferColumnDefinition(outTable, inTable, dataColumn, NULL) ||
      (eventRows = SDDS_RowCount(inTable)) == 0 ||
      !(eventValue = SDDS_GetColumn(inTable, eventIDColumn)) ||
      !(*dataRet = eventDataValue = SDDS_GetColumnInDoubles(inTable, dataColumn)))
    return 0;
  if (columnMajorOrder != -1)
    outTable->layout.data_mode.column_major = columnMajorOrder;
  else
    outTable->layout.data_mode.column_major = inTable->layout.data_mode.column_major;
 
  if (!(eventPair = SDDS_Malloc(sizeof(*eventPair) * eventRows)))
    SDDS_Bomb("Memory allocation failure.");
 
  /* Populate eventPair with event strings and data */
  for (row = 0; row < eventRows; row++) {
    eventPair[row].string = eventValue[row];
    eventPair[row].data = eventDataValue[row];
  }
  qsort(eventPair, eventRows, sizeof(*eventPair), event_cmpasc);
 
  /* Count unique events */
  uniqueRows = 1;
  for (row = 1; row < eventRows; row++) {
    if (strcmp(eventPair[row - 1].string, eventPair[row].string) != 0)
      uniqueRows++;
  }
  *eventIDsRet = uniqueRows;
 
  /* Allocate and populate EVENT_DATA structures */
  if (!(eventData = *eventDataRet = SDDS_Malloc(sizeof(**eventDataRet) * uniqueRows)))
    SDDS_Bomb("Memory allocation failure.");
  row0 = 0;
  iEvent = 0;
  for (row = 1; row < eventRows; row++) {
    if (row == (eventRows - 1) || strcmp(eventPair[row].string, eventPair[row0].string) != 0) {
      /* [row0, row-1] have the same event name */
      eventData[iEvent].events = row - row0;
      if (!SDDS_CopyString(&eventData[iEvent].string, eventPair[row0].string) ||
          !(eventData[iEvent].data = SDDS_Malloc(sizeof(*eventData[iEvent].data) * eventData[iEvent].events)))
        SDDS_Bomb("Memory allocation failure");
      for (drow = 0; drow < eventData[iEvent].events; drow++) {
        eventData[iEvent].data[drow] = eventPair[row0 + drow].data;
        /* free(eventPair[row0+drow].string); */
      }
      if (row == (eventRows - 1) && strcmp(eventPair[row].string, eventPair[row0].string) != 0) {
        /* this is necessary to pick up the last event if it is a loner */
        row0 = row;
        row--;
      } else {
        row0 = row;
      }
      iEvent++;
    }
  }
 
  free(eventPair);
  for (row = 0; row < eventRows; row++)
    free(eventValue[row]);
  free(eventValue);
  if (iEvent != uniqueRows)
    SDDS_Bomb("Unique row count mismatch.");
 
  if (overlapEventID && strlen(overlapEventID)) {
    for (iEvent = 0; iEvent < uniqueRows; iEvent++) {
      if (strcmp(overlapEventID, eventData[iEvent].string) == 0)
        break;
    }
    if (iEvent == uniqueRows)
      SDDS_Bomb("Overlap event not found.");
  }
 
  for (row = 0; row < uniqueRows; row++) {
    snprintf(buffer, sizeof(buffer), "%sFrequency", eventData[row].string);
    if ((eventData[row].histogramIndex = SDDS_DefineColumn(outTable, buffer, NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0)) < 0)
      return 0;
    eventData[row].overlapIndex = -1;
    if (overlapEventID) {
      snprintf(buffer, sizeof(buffer), "%s.%sOverlap", eventData[row].string, overlapEventID);
      if ((eventData[row].overlapIndex = SDDS_DefineColumn(outTable, buffer, NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0)) < 0)
        return 0;
    }
  }
 
  if (SDDS_DefineParameter(outTable, "sddseventhistInput", NULL, NULL, NULL, NULL, SDDS_STRING,
                           inputfile) < 0 ||
      SDDS_DefineParameter(outTable, "sddseventhistBins", NULL, NULL, NULL, NULL, SDDS_LONG,
                           NULL) < 0 ||
      SDDS_DefineParameter(outTable, "sddseventhistBinSize", NULL, NULL, NULL, NULL,
                           SDDS_DOUBLE, NULL) < 0 ||
      SDDS_DefineParameter(outTable, "sddseventhistPointsBinned", NULL, NULL, NULL, NULL, SDDS_LONG,
                           NULL) < 0 ||
      SDDS_DefineParameter(outTable, "sddseventhistEventIDColumn", NULL, NULL, NULL, NULL,
                           SDDS_STRING, eventIDColumn) < 0 ||
      SDDS_DefineParameter(outTable, "sddshistNormMode", NULL, NULL, NULL, NULL, SDDS_STRING, normalize_option[normalizeMode]) < 0 ||
      !SDDS_TransferAllParameterDefinitions(outTable, inTable, SDDS_TRANSFER_KEEPOLD) || !SDDS_WriteLayout(outTable))
    return 0;
  return 1;
}

Variable Documentation

additional_help

char* additional_help

static

Initial value:

= "\n\
dataColumn       : Name of the column to histogram.\n\
eventIdentifier  : Name of the column used to identify events.\n\
                   A separate histogram is created for each unique value in this column.\n\
                   The column must contain string or integer data;\n\
                   if string data, the values must be valid SDDS column names.\n\
overlapEvent     : If specified, histograms are multiplied bin-by-bin with this event's histogram.\n\
bins             : Number of bins for the histogram.\n\
sizeOfBins       : Size of each bin for the histogram.\n\
lowerLimit       : Lower limit of the histogram range.\n\
upperLimit       : Upper limit of the histogram range.\n\
normalize        : Normalize the histogram by sum, area, or peak.\n\
sides            : Adds sides to the histogram down to the zero level.\n\
majorOrder       : Specifies the major order for the output file (row or column).\n\n\
Program by Michael Borland.  (" __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION ")\n"

Definition at line 98 of file sddseventhist.c.

normalize_option

char* normalize_option[N_NORMALIZE_OPTIONS]

Initial value:

= {
  "peak", "area", "sum", "no"}

Definition at line 120 of file sddseventhist.c.

                                              {
  "peak", "area", "sum", "no"};

option

char* option[N_OPTIONS]

Initial value:

= {
  "bins",
  "lowerlimit",
  "upperlimit",
  "datacolumn",
  "sizeofbins",
  "normalize",
  "sides",
  "pipe",
  "eventidentifier",
  "overlapevent",
  "majorOrder",
}

Definition at line 70 of file sddseventhist.c.

                          {
  "bins",
  "lowerlimit",
  "upperlimit",
  "datacolumn",
  "sizeofbins",
  "normalize",
  "sides",
  "pipe",
  "eventidentifier",
  "overlapevent",
  "majorOrder",
};

USAGE

char* USAGE

Initial value:

=
  "Usage: sddseventhist [<inputfile>] [<outputfile>]\n"
  "       [-pipe=<input>,<output>]\n"
  "       -dataColumn=<columnName>\n"
  "       -eventIdentifier=<columnName>\n"
  "       [-overlapEvent=<eventValue>]\n"
  "       [{-bins=<number> | -sizeOfBins=<value>}]\n"
  "       [-lowerLimit=<value>]\n"
  "       [-upperLimit=<value>]\n"
  "       [-sides]\n"
  "       [-normalize[={sum|area|peak}]]\n"
  "       [-majorOrder=row|column]\n"

Definition at line 85 of file sddseventhist.c.