sddsrespmatrixderivative.c File Reference

Detailed Description

Calculates the response matrix derivative with respect to correctors, BPMs, or quadrupoles.

This program processes an input SDDS response matrix file to compute its derivative with respect to selected elements such as correctors ("cor"), Beam Position Monitors (BPMs, "bpm"), or quadrupoles ("quad"). Additional options allow users to append zero rows before or after the main data. Supported modes and options are described below.

Usage

sddsrespmatrixderivative [<inputfile>] [<outputfile>]
                         [-pipe=[input][,output]]
                          -mode=<string> 
                         [-addRowsBefore=<number>] 
                         [-addRowsAfter=<number>] 
                         [-verbose]

Options

Required	Description
-mode=<string>	Mode of derivative: cor, bpm or quad

Optional	Description
-pipe=[input][,output]	Read input from and/or write output to a pipe.
-addRowsBefore=<number>	Add zero rows before meaningful rows. Default: 0.
-addRowsAfter=<number>	Add zero rows after meaningful rows. Default: 0.
-verbose	Enable detailed logging to stderr.

Incompatibilities

• When -mode=quad is specified:
  • -addRowsBefore is treated as the starting column number for diagonal output.
  • -addRowsAfter specifies the number of rows of diagonal output.

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

R. Soliday

Definition in file sddsrespmatrixderivative.c.

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

Go to the source code of this file.

Functions
char **	TokenizeString (char *source, long n_items)
char *	JoinStrings (char **source, long n_items, long buflen_increment)
int	MakeDerivative (char *mode, int addRowsBefore, int addRowsAfter, int addColumnsBefore, MATRIX *B, MATRIX *A)
int	MakeRootnameColumn (char *mode, long inputDoubleColumns, int64_t inputRows, long addRowsBefore, long addRowsAfter, char **inputDoubleColumnName, char **stringData, char **rootnameData)
int	main (int argc, char **argv)

Function Documentation

JoinStrings()

char * JoinStrings	(	char **	source,
		long	n_items,
		long	buflen_increment )

Definition at line 720 of file sddstranspose.c.

                                                                      {
  char *buffer;
  char *ptr;
  long buffer_size, bufferLeft, bufferUsed;
  long i, slen;
  char *sptr;
 
  buffer_size = buflen_increment;
  buffer = (char *)malloc(sizeof(char) * buffer_size);
  buffer[0] = '\0';
  ptr = buffer;
  bufferLeft = buffer_size - 2;
  bufferUsed = 0;
  for (i = 0; i < n_items; i++) {
    sptr = source[i];
    slen = strlen(sptr);
    while ((slen + 5) > bufferLeft) {
      buffer = trealloc(buffer, sizeof(char) * (buffer_size += buflen_increment));
      bufferLeft += buflen_increment;
      ptr = buffer + bufferUsed;
    }
    if (i) {
      slen++;
      *ptr++ = ' ';
    }
    *ptr++ = '"';
    while (*sptr)
      *ptr++ = *sptr++;
    *ptr++ = '"';
    *ptr = '\0';
    bufferLeft -= slen + 2;
    bufferUsed += slen + 2;
  }
 
  return buffer;
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 100 of file sddsrespmatrixderivative.c.

                                {
  SCANNED_ARG *s_arg;
  SDDS_DATASET inputPage, outputPage;
 
  char *inputfile, *outputfile;
  char **inputColumnName, **inputStringColumnName, **inputDoubleColumnName;
  char **outputStringColumnName, **outputDoubleColumnName;
  int64_t inputRows, outputRows;
  long inputDoubleColumns, inputStringColumns;
  long outputDoubleColumns, outputStringColumns;
  char **inputParameterName;
  int32_t inputParameters, inputColumns;
  char *inputDescription, *inputContents;
  long i, i_arg, col;
#define BUFFER_SIZE_INCREMENT 16384
  MATRIX *R, *Rderiv;
  long OldStringColumnsDefined;
  long verbose;
  long ascii;
  unsigned long pipeFlags;
  long tmpfile_used, noWarnings;
  long ipage, columnType;
  long addRowsBefore, addRowsAfter, addColumnsBefore;
  char *mode;
  char **stringData = NULL;
  char **rootnameData = NULL;
 
  inputColumnName = outputStringColumnName = outputDoubleColumnName = inputParameterName = NULL;
  outputRows = outputDoubleColumns = outputStringColumns = OldStringColumnsDefined = 0;
 
  SDDS_RegisterProgramName(argv[0]);
 
  argc = scanargs(&s_arg, argc, argv);
  if (argc == 1)
    bomb(NULL, USAGE);
 
  inputfile = outputfile = NULL;
  verbose = 0;
  ascii = 0;
  pipeFlags = 0;
  tmpfile_used = 0;
  noWarnings = 0;
  mode = NULL;
  int modeDefined = 0;
  addRowsBefore = 0;
  addRowsAfter = 0;
 
  for (i_arg = 1; i_arg < argc; i_arg++) {
    if (s_arg[i_arg].arg_type == OPTION) {
      delete_chars(s_arg[i_arg].list[0], "_");
      switch (match_string(s_arg[i_arg].list[0], commandline_option, N_OPTIONS, UNIQUE_MATCH)) {
      case CLO_VERBOSE:
        verbose = 1;
        break;
      case CLO_PIPE:
        if (!processPipeOption(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1, &pipeFlags))
          SDDS_Bomb("Invalid -pipe syntax");
        break;
      case CLO_MODE:
        modeDefined = 1;
        if (!(mode = s_arg[i_arg].list[1]))
          SDDS_Bomb("No mode string provided");
        break;
      case CLO_ADDROWSBEFORE:
        if (!(sscanf(s_arg[i_arg].list[1], "%ld", &addRowsBefore)) || (addRowsBefore < 0))
          SDDS_Bomb("Invalid value for addRowsBefore: must be a non-negative number");
        break;
      case CLO_ADDROWSAFTER:
        if (!(sscanf(s_arg[i_arg].list[1], "%ld", &addRowsAfter)) || (addRowsAfter < 0))
          SDDS_Bomb("Invalid value for addRowsAfter: must be a non-negative number");
        break;
      default:
        bomb("Unrecognized option provided", USAGE);
      }
    } else {
      if (!inputfile)
        inputfile = s_arg[i_arg].list[0];
      else if (!outputfile)
        outputfile = s_arg[i_arg].list[0];
      else
        bomb("Too many filenames provided", USAGE);
    }
  }
 
  if (modeDefined) {
    if (strcmp(mode, "cor") && strcmp(mode, "bpm") && strcmp(mode, "quad")) {
      bomb("Invalid mode parameter", "Mode must be 'cor', 'bpm', or 'quad'");
    }
  } else {
    bomb("Mode parameter is not defined.", "Mode must be 'cor', 'bpm', or 'quad'");
  }
 
  processFilenames("sddsrespmatrixderivative", &inputfile, &outputfile, pipeFlags, noWarnings, &tmpfile_used);
 
  if (!SDDS_InitializeInput(&inputPage, inputfile) ||
      !(inputColumnName = (char **)SDDS_GetColumnNames(&inputPage, &inputColumns)) ||
      !(inputParameterName = (char **)SDDS_GetParameterNames(&inputPage, &inputParameters)) ||
      !SDDS_GetDescription(&inputPage, &inputDescription, &inputContents)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(EXIT_FAILURE);
  }
 
  inputDoubleColumns = 0;
  inputStringColumns = 0;
  inputDoubleColumnName = (char **)malloc(inputColumns * sizeof(char *));
  inputStringColumnName = (char **)malloc(inputColumns * sizeof(char *));
  inputRows = 0;
 
  if (strcmp(mode, "quad") == 0) {
    addColumnsBefore = addRowsBefore;
    addRowsBefore = 0;
  } else {
    addColumnsBefore = 0;
  }
 
  /* Read data */
  while (0 < (ipage = SDDS_ReadTable(&inputPage))) {
    if (ipage == 1) {
      if (!SDDS_SetColumnFlags(&inputPage, 0))
        SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
 
      /* Count the string and numerical columns in the input file */
      for (i = 0; i < inputColumns; i++) {
        if (SDDS_NUMERIC_TYPE(columnType = SDDS_GetColumnType(&inputPage, i))) {
          inputDoubleColumnName[inputDoubleColumns] = inputColumnName[i];
          inputDoubleColumns++;
        } else if (columnType == SDDS_STRING) {
          inputStringColumnName[inputStringColumns] = inputColumnName[i];
          inputStringColumns++;
        }
      }
 
      if (!(inputRows = SDDS_CountRowsOfInterest(&inputPage)))
        SDDS_Bomb("No rows in dataset.");
    } else {
      SDDS_Bomb("Dataset must be one-page.");
    }
 
    if (inputDoubleColumns == 0)
      SDDS_Bomb("No numerical columns in file.");
 
    if ((ipage == 1) && verbose) {
      fprintf(stderr, "Number of numerical columns: %ld.\n", inputDoubleColumns);
      fprintf(stderr, "Number of string columns: %ld.\n", inputStringColumns);
      fprintf(stderr, "Number of rows: %" PRId64 ".\n", inputRows);
    }
 
    /* Work on data */
    if (inputDoubleColumns) {
      m_alloc(&R, inputDoubleColumns, inputRows);
      outputRows = inputDoubleColumns * inputRows + addRowsBefore + addRowsAfter;
 
      if (strcmp(mode, "cor") == 0) {
        m_alloc(&Rderiv, inputDoubleColumns, outputRows);
      } else if (strcmp(mode, "bpm") == 0) {
        m_alloc(&Rderiv, inputRows, outputRows);
      } else {
        outputRows = addRowsAfter;
        m_alloc(&Rderiv, inputDoubleColumns, outputRows);
      }
 
      for (col = 0; col < inputDoubleColumns; col++) {
        if (!(R->a[col] = (double *)SDDS_GetColumnInDoubles(&inputPage, inputDoubleColumnName[col]))) {
          SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
        }
      }
 
      /* Read stringData only in non-quad mode */
      if (strcmp(mode, "quad") != 0) {
        if (!(stringData = SDDS_GetColumn(&inputPage, "BPMName"))) {
          SDDS_SetError("Unable to read specified column: BPMName.");
          SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
          return EXIT_FAILURE;
        }
      }
    }
 
    if ((ipage == 1) && verbose) {
      fprintf(stderr, "Starting MakeDerivative...\n");
    }
 
    MakeDerivative(mode, addRowsBefore, addRowsAfter, addColumnsBefore, Rderiv, R);
 
    rootnameData = (char **)malloc(outputRows * sizeof(char *));
    if ((ipage == 1) && verbose) {
      fprintf(stderr, "Starting MakeRootnameColumn...\n");
    }
 
    MakeRootnameColumn(mode, inputDoubleColumns, inputRows, addRowsBefore, addRowsAfter,
                       inputDoubleColumnName, stringData, rootnameData);
 
    /* Define output page */
    if ((ipage == 1) && verbose) {
      fprintf(stderr, "Starting output...\n");
    }
 
    if (ipage == 1) {
      if (strcmp(mode, "cor") == 0) {
        outputDoubleColumns = inputDoubleColumns;
        outputDoubleColumnName = inputDoubleColumnName;
      } else if (strcmp(mode, "bpm") == 0) {
        outputDoubleColumns = inputRows;
        outputDoubleColumnName = stringData;
      } else {
        outputDoubleColumns = inputDoubleColumns;
        outputDoubleColumnName = inputDoubleColumnName;
      }
 
      if (!SDDS_InitializeOutput(&outputPage, ascii ? SDDS_ASCII : SDDS_BINARY, 1, NULL, NULL, outputfile))
        SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
      /* Define string columns */
      outputStringColumns = 1;
      outputStringColumnName = (char **)malloc(sizeof(char *));
      outputStringColumnName[0] = "Rootname";
      if (SDDS_DefineColumn(&outputPage, outputStringColumnName[0], NULL, NULL, NULL, NULL, SDDS_STRING, 0) < 0)
        SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
      /* Define double columns */
      for (i = 0; i < outputDoubleColumns; i++) {
        if (SDDS_DefineColumn(&outputPage, outputDoubleColumnName[i], NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0) < 0)
          SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      }
 
      /* Write layout */
      switch (SDDS_CheckParameter(&outputPage, "InputFile", NULL, SDDS_STRING, NULL)) {
      case SDDS_CHECK_NONEXISTENT:
        if (SDDS_DefineParameter(&outputPage, "InputFile", NULL, NULL, "Original matrix file", NULL, SDDS_STRING, NULL) < 0)
          SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
        break;
      default:
        break;
      }
 
      if (!SDDS_WriteLayout(&outputPage))
        SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    }
 
    if (!SDDS_StartTable(&outputPage, outputRows))
      SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
    if (ipage == 1) {
      if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, "InputFile", inputfile ? inputfile : "pipe", NULL))
        SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    }
 
    /* Assign data to output table part of data set */
 
    /* Assign string column data */
    if (!SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME | SDDS_PASS_BY_REFERENCE, rootnameData, outputRows, outputStringColumnName[0]))
      SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
    /* Assign double column data */
    for (i = 0; i < outputDoubleColumns; i++) {
      if (!SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME | SDDS_PASS_BY_REFERENCE, Rderiv->a[i], outputRows, outputDoubleColumnName[i]))
        SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    }
  }
 
  if (!SDDS_WriteTable(&outputPage))
    SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
  if (outputDoubleColumns) {
    m_free(&R);
    m_free(&Rderiv);
    free(rootnameData);
  }
 
  if (!SDDS_Terminate(&inputPage) || !SDDS_Terminate(&outputPage))
    SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
  if (tmpfile_used && !replaceFileAndBackUp(inputfile, outputfile))
    exit(EXIT_FAILURE);
 
  return EXIT_SUCCESS;
}

MakeDerivative()

int MakeDerivative	(	char *	mode,
		int	addRowsBefore,
		int	addRowsAfter,
		int	addColumnsBefore,
		MATRIX *	B,
		MATRIX *	A )

Definition at line 424 of file sddsrespmatrixderivative.c.

                                                                                                                {
  register long i, j;
  long Ncols, Nrows;
 
  Ncols = A->n;
  Nrows = A->m;
 
  /* Initialize matrix B to zero */
  for (i = 0; i < B->n; i++) {
    for (j = 0; j < B->m; j++) {
      B->a[i][j] = 0.0;
    }
  }
 
  if (strcmp(mode, "cor") == 0) {
    for (i = 0; i < Ncols; i++) {
      for (j = 0; j < Nrows; j++) {
        B->a[i][i + j * Ncols + addRowsBefore] = A->a[i][j];
      }
    }
  } else if (strcmp(mode, "bpm") == 0) {
    for (i = 0; i < Nrows; i++) {
      for (j = 0; j < Ncols; j++) {
        B->a[i][i * Ncols + j + addRowsBefore] = A->a[j][i];
      }
    }
  } else { /* mode == "quad" */
    for (i = 0; i < addRowsAfter; i++) {
      B->a[i + addColumnsBefore][i] = 1.0;
    }
  }
 
  return EXIT_SUCCESS;
}

MakeRootnameColumn()

int MakeRootnameColumn	(	char *	mode,
		long	inputDoubleColumns,
		int64_t	inputRows,
		long	addRowsBefore,
		long	addRowsAfter,
		char **	inputDoubleColumnName,
		char **	stringData,
		char **	rootnameData )

Definition at line 379 of file sddsrespmatrixderivative.c.

                                                                                             {
  int64_t i, j, n;
 
  n = 0;
  for (i = 0; i < addRowsBefore; i++) {
    rootnameData[n] = (char *)malloc(sizeof(char) * 1);
    rootnameData[n][0] = '\0'; // Initialize to empty string
    n++;
  }
 
  if (strcmp(mode, "quad") == 0) {
    for (i = 0; i < addRowsAfter; i++) {
      if (addRowsAfter > inputDoubleColumns) {
        SDDS_SetError("Number of addRowsAfter is greater than number of input columns in quad mode.");
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        return EXIT_FAILURE;
      }
      rootnameData[n] = (char *)malloc(sizeof(char) * (strlen(inputDoubleColumnName[i]) + 1));
      strcpy(rootnameData[n], inputDoubleColumnName[i]);
      n++;
    }
  } else {
    for (i = 0; i < inputRows; i++) {
      for (j = 0; j < inputDoubleColumns; j++) {
        size_t len = strlen(inputDoubleColumnName[j]) + strlen(stringData[i]) + 1;
        rootnameData[n] = (char *)malloc(sizeof(char) * (len + 1));
        strcpy(rootnameData[n], inputDoubleColumnName[j]);
        strcat(rootnameData[n], stringData[i]);
        n++;
      }
    }
    /* Only in non-quad mode, add additional rows after */
    for (i = 0; i < addRowsAfter; i++) {
      rootnameData[n] = (char *)malloc(sizeof(char) * 1);
      rootnameData[n][0] = '\0'; // Initialize to empty string
      n++;
    }
  }
 
  return EXIT_SUCCESS;
}

TokenizeString()

char ** TokenizeString	(	char *	source,
		long	n_items )

Definition at line 697 of file sddstranspose.c.

                                                  {
  char *buffer;
  long buflen;
  char *ptr;
  char **string_array;
  long i;
 
  if (!source)
    return NULL;
  ptr = source;
  string_array = (char **)malloc(sizeof(char *) * n_items);
  buflen = strlen(source) + 1;
  buffer = (char *)malloc(sizeof(char) * buflen);
  for (i = 0; i < n_items; i++) {
    if (SDDS_GetToken(ptr, buffer, buflen) != -1)
      SDDS_CopyString(&string_array[i], buffer);
    else
      SDDS_CopyString(&string_array[i], "");
  }
  free(buffer);
  return string_array;
}