bpminterface/load_bpmconf.c

Go to the documentation of this file.

#include <stdio.h>
#include <bpm/bpm_messages.h>
#include <bpm/bpm_interface.h>
#include <bpm/bpm_version.h>
#include <bpm/bpm_units.h>

int load_bpmconf( const char* fname, bpmconf_t **conf, int *num_conf ){

  if ( ! fname ) {
    bpm_error( "Invalid filename in load_bpmconf(...)",
               __FILE__, __LINE__ );
    return BPM_FAILURE;
  }

  if ( ! conf ) {
    bpm_error( "Invalid configuration pointer in load_bpmconf(...)",
               __FILE__, __LINE__ );
    return BPM_FAILURE;
  }

  if ( ! num_conf ) {
    bpm_error( "Invalid number pointer in load_bpmconf(...)",
               __FILE__, __LINE__ );
    return BPM_FAILURE;
  }

  /*--------------------------------------------------------------------------
    First, open the file, load the header info and create the structures
    --------------------------------------------------------------------------
  */
  
  FILE *conf_file = fopen( fname, "r" );
  int ibpm;

  if ( ! conf_file ) {
    char buf[255];

    sprintf( buf, "Unable to open file \"%s\" in load_bpmconf(...)", fname );
    bpm_error( buf, __FILE__, __LINE__ );

    return BPM_FAILURE;
  }

  // Retrieve the header info
  int num_structs;
  double version;
  if ( get_header( conf_file, &version, &num_structs ) == BPM_FAILURE ) {
    char buf[255];

    sprintf( buf, "Unable to load/find header info in file \"%s\" ", fname );
    bpm_error( buf, __FILE__, __LINE__ );

    return BPM_FAILURE;
  }
    
  // Check version
  if ( version != BPM_VERSION_VAL ) {
    char buf[255];
    
    sprintf( buf, "Version of file \"%s\" does not match current libbpm version", fname );
    bpm_warning( buf, __FILE__, __LINE__ );
  }
  
  // Create the structures
  *num_conf = num_structs;
  *conf = (bpmconf_t*) calloc( *num_conf, sizeof(bpmconf_t) );

  // Reset to deafult values
  int ipar;
  for ( ibpm = 0; ibpm < *num_conf; ibpm++ ) {

    (*conf)[ibpm].cav_type = dipole;
    (*conf)[ibpm].cav_polarisation = vert;
    (*conf)[ibpm].cav_phasetype = locked;
    (*conf)[ibpm].cav_freq = 0;
    (*conf)[ibpm].cav_decaytime = 0;
    (*conf)[ibpm].cav_phase = 0;
    (*conf)[ibpm].cav_iqrotation = 0;
    (*conf)[ibpm].cav_chargesens = 0;
    (*conf)[ibpm].cav_possens = 0;
    (*conf)[ibpm].cav_tiltsens = 0;

    (*conf)[ibpm].rf_LOfreq = 0;
    (*conf)[ibpm].rf_filtertype = nofilter;
    (*conf)[ibpm].rf_nfiltpars = 0;
    (*conf)[ibpm].rf_filterpars = NULL;
    (*conf)[ibpm].rf_gain = 0;

    (*conf)[ibpm].digi_trigtimeoffset = 0.;
    (*conf)[ibpm].digi_freq = 100 * MHz;
    (*conf)[ibpm].digi_nbits = 14;
    (*conf)[ibpm].digi_nsamples = 256;
    (*conf)[ibpm].digi_ampnoise = 0.;
    (*conf)[ibpm].digi_voltageoffset = 8192;
    (*conf)[ibpm].digi_phasenoise = 0;

    for ( ipar = 0; ipar < 3; ipar++) {
      (*conf)[ibpm].geom_pos[ipar] = 0;
      (*conf)[ibpm].geom_tilt[ipar] = 0;
    }

    (*conf)[ibpm].ref_idx = 0;
    (*conf)[ibpm].diode_idx = 0;
  }

  /*--------------------------------------------------------------------------
    Next, load in each structure and fill them
    --------------------------------------------------------------------------
  */
  char **args, **arg_val;
  int num_args, iarg;

  for ( ibpm = 0; ibpm < *num_conf; ibpm++ ) {
      
      // Load in the structures
      load_struct( conf_file, &args, &arg_val, &num_args );

      // Fill the configurations from the arguments
      int bpm_temp_idx = -1;

      for ( iarg = 0; iarg < num_args; iarg++ ) {
          
        // Index of this structure
        if ( strcmp( "bpm_idx", args[iarg] ) == 0 ) {
          bpm_temp_idx = atoi( arg_val[iarg] );
          break;
        }
      }

      if ( bpm_temp_idx == -1 ) {
        bpm_error( "Index not specified BPM config structure in load_bpmconf(...)",
                   __FILE__, __LINE__ );
      }
      
      // Now for all the other parameters
      for ( iarg = 0; iarg < num_args; iarg++ ) {

        // Occasionally, there is a trailing whitespace added to the parameters. This gets rid of them.
        // If you can figure out why, do let me know!
        if ( ! isalnum( args[iarg][ strlen(args[iarg]) - 1 ] ) ) 
          args[iarg][ strlen(args[iarg]) - 1 ] = '\0';

        if ( ! isalnum( arg_val[iarg][ strlen(arg_val[iarg]) - 1 ] ) ) 
          {
            arg_val[iarg][ strlen(arg_val[iarg]) - 1 ] = '\0';
          }

        if ( strcmp( "bpm_name", args[iarg] ) == 0 ) {
          // ---------------------------------------------------------
          // BPM name
          if ( strlen( arg_val[iarg] ) > 20 ) {
            char buf[255];
            sprintf(buf, "BPM name \"%s\" too long. Truncating in load_bpmconf(...)", arg_val[iarg]);
            bpm_warning( buf, __FILE__, __LINE__);
            
            arg_val[iarg][20] = '\0';
          }
          
          strcpy((*conf)[bpm_temp_idx].name, arg_val[iarg]);
        } 
        else if ( strcmp( "cav_type", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Cavity Type

          // What is the cavity type?
          if (strcmp( "diode", arg_val[iarg] ) == 0 ) (*conf)[bpm_temp_idx].cav_type = diode;
          else if (strcmp( "monopole", arg_val[iarg] ) == 0 ) (*conf)[bpm_temp_idx].cav_type = monopole;
          else if (strcmp( "dipole", arg_val[iarg] ) == 0 ) (*conf)[bpm_temp_idx].cav_type = dipole;
          else {
            char buf[255];
         
            sprintf( buf, "Unknown cavity type \"%s\". Defaulting to dipole in load_bpmconf(...)", 
                     arg_val[iarg] );
            bpm_warning( buf, __FILE__, __LINE__ );
            (*conf)[bpm_temp_idx].cav_type = dipole;
          }
        }
        else if ( strcmp( "cav_polarisation", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Cavity Polarisation

          // What is the polarisation?
          if (strcmp( "horiz", arg_val[iarg] ) == 0 ) (*conf)[bpm_temp_idx].cav_polarisation = horiz;
          else if (strcmp( "vert", arg_val[iarg] ) == 0 ) (*conf)[bpm_temp_idx].cav_polarisation = vert;
          else {
            char buf[255];
         
            sprintf( buf, "Unknown cavity polarisation \"%s\". Defaulting to vert in load_bpmconf(...)", 
                     arg_val[iarg] );
            bpm_warning( buf, __FILE__, __LINE__ );
            (*conf)[bpm_temp_idx].cav_polarisation = vert;
          }
        }
        else if ( strcmp( "cav_phasetype", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Cavity phase type

          // What is the phase type?
          if (strcmp( "randomised", arg_val[iarg] ) == 0 ) (*conf)[bpm_temp_idx].cav_phasetype = randomised;
          else if (strcmp( "locked", arg_val[iarg] ) == 0 ) (*conf)[bpm_temp_idx].cav_phasetype = locked;
          else {
            char buf[255];
         
            sprintf( buf, "Unknown cavity phase type \"%s\". Defaulting to locked in load_bpmconf(...)", 
                     arg_val[iarg] );
            bpm_warning( buf, __FILE__, __LINE__ );
            (*conf)[bpm_temp_idx].cav_phasetype = locked;
          }
        }
        else if ( strcmp( "cav_freq", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Cavity frequency
          (*conf)[bpm_temp_idx].cav_freq = atof( arg_val[iarg] );
        }
        else if ( strcmp( "cav_decaytime", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Cavity decay time
          (*conf)[bpm_temp_idx].cav_decaytime = atof( arg_val[iarg] );
        }
        else if ( strcmp( "cav_phase", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Cavity Phase advance wrt to ref
          (*conf)[bpm_temp_idx].cav_phase = atof( arg_val[iarg] );
        }
        else if ( strcmp( "cav_iqrotation", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Cavity IQ rotation
          (*conf)[bpm_temp_idx].cav_iqrotation = atof( arg_val[iarg] );
        }
        else if ( strcmp( "cav_chargesens", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Cavity charge sensitivity
          (*conf)[bpm_temp_idx].cav_chargesens = atof( arg_val[iarg] );
        }
        else if ( strcmp( "cav_possens", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Cavity position sensitivity
          (*conf)[bpm_temp_idx].cav_possens = atof( arg_val[iarg] );
        }
        else if ( strcmp( "cav_tiltsens", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Cavity tilt sensitivity
          (*conf)[bpm_temp_idx].cav_tiltsens = atof( arg_val[iarg] );
        }
        else if ( strcmp( "rf_LOfreq", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // LO frequency of rf
          (*conf)[bpm_temp_idx].rf_LOfreq = atof( arg_val[iarg] );
        }       
        else if ( strcmp( "rf_filtertype", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // RF Filter type
          // What is the phase type?
          if (strcmp( "butterworth_low_pass", arg_val[iarg] ) == 0 ) {
            (*conf)[bpm_temp_idx].rf_filtertype = butterworth_low_pass;
          }
          else if (strcmp( "butterworth_band_pass", arg_val[iarg] ) == 0 ) {
            (*conf)[bpm_temp_idx].rf_filtertype = butterworth_band_pass;
          }
          else if (strcmp( "butterworth_high_pass", arg_val[iarg] ) == 0 ) {
            (*conf)[bpm_temp_idx].rf_filtertype = butterworth_high_pass;
          }
          else if (strcmp( "nofilter", arg_val[iarg] ) == 0 ) {
            (*conf)[bpm_temp_idx].rf_filtertype = nofilter;
          }
          else {
            char buf[255];
         
            sprintf( buf, "Unknown rf filter type \"%s\". Defaulting to nofilter in load_bpmconf(...)", 
                     arg_val[iarg] );
            bpm_warning( buf, __FILE__, __LINE__ );
            (*conf)[bpm_temp_idx].cav_phasetype = nofilter;
          }      
        }
        else if ( strcmp( "rf_nfiltpars", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Number of RF filter parameters
          (*conf)[bpm_temp_idx].rf_nfiltpars = atoi( arg_val[iarg] );
          (*conf)[bpm_temp_idx].rf_filterpars = calloc( (*conf)[bpm_temp_idx].rf_nfiltpars,
                                                        sizeof(double) );
        }
        else if ( strcmp( "rf_filterpars", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Filter parameters
          if ( ! (*conf)[bpm_temp_idx].rf_filterpars ) {
            bpm_warning( "Filter parameters given before specifying number of pars. Ignoring in load_bpmconf(...)", 
                         __FILE__, __LINE__ );
          }

          int ipar;
          char *tok = strtok( arg_val[iarg], " " );
          for ( ipar = 0; ipar < (*conf)[bpm_temp_idx].rf_nfiltpars; ipar++ ) {

            (*conf)[bpm_temp_idx].rf_filterpars[ipar] = atof( tok );
            tok = strtok( NULL, " " );
          }
        }
        else if ( strcmp( "rf_gain", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Gain of the electronics
          (*conf)[bpm_temp_idx].rf_gain = atof( arg_val[iarg] );
        }
        else if ( strcmp( "digi_trigtimeoffset", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Bunch arrival time offset
          (*conf)[bpm_temp_idx].digi_trigtimeoffset = atof( arg_val[iarg] );
        }
        else if ( strcmp( "digi_freq", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Digitisation frequency
          (*conf)[bpm_temp_idx].digi_freq = atof( arg_val[iarg] );
        }
        else if ( strcmp( "digi_nbits", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Number of bits
          (*conf)[bpm_temp_idx].digi_nbits = atoi( arg_val[iarg] );
        }
        else if ( strcmp( "digi_nsamples", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Number of digi samples
          (*conf)[bpm_temp_idx].digi_nsamples = atoi( arg_val[iarg] );
        }
        else if ( strcmp( "digi_ampnoise", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Amplitude noise
          (*conf)[bpm_temp_idx].digi_ampnoise = atof( arg_val[iarg] );
        }
        else if ( strcmp( "digi_voltageoffset", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Pedestal position
          (*conf)[bpm_temp_idx].digi_voltageoffset = atoi( arg_val[iarg] );
        }
        else if ( strcmp( "digi_phasenoise", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Phase nosie
          (*conf)[bpm_temp_idx].digi_phasenoise = atof( arg_val[iarg] );
        }       
        else if ( strcmp( "geom_pos", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // BPM Position
          int ipar;
          char *tok = strtok( arg_val[iarg], " " );
          for ( ipar = 0; ipar < 3; ipar++ ) {

            (*conf)[bpm_temp_idx].geom_pos[ipar] = atof( tok );
            tok = strtok( NULL, " " );
          }
        }
        else if ( strcmp( "geom_tilt", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // BPM Tilt
          int ipar;
          char *tok = strtok( arg_val[iarg], " " );
          for ( ipar = 0; ipar < 3; ipar++ ) {

            (*conf)[bpm_temp_idx].geom_tilt[ipar] = atof( tok );
            tok = strtok( NULL, " " );
          }
        }
        else if ( strcmp( "ref_idx", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Index of reference BPM
          (*conf)[bpm_temp_idx].ref_idx = atoi( arg_val[iarg] );        

          if ( ((*conf)[bpm_temp_idx].cav_type != diode ) && ((*conf)[bpm_temp_idx].cav_type != monopole ) 
               && (( (*conf)[bpm_temp_idx].ref_idx >= *num_conf) || ( (*conf)[bpm_temp_idx].ref_idx < 0))) {
            char buf[255];
         
            sprintf( buf, "Reference index (%d) outside range of BPM structure in load_bpmconf(...)",
                     (*conf)[bpm_temp_idx].ref_idx );
            bpm_warning(buf, __FILE__, __LINE__ );
          }
        }
        else if ( strcmp( "diode_idx", args[iarg] ) == 0 ) {

          // ---------------------------------------------------------
          // Index of Diode
          (*conf)[bpm_temp_idx].diode_idx = atoi( arg_val[iarg] );
          
          if ( ((*conf)[bpm_temp_idx].cav_type != diode ) &&
              (( (*conf)[bpm_temp_idx].diode_idx >= *num_conf) || ( (*conf)[bpm_temp_idx].diode_idx < 0))) {
            char buf[255];
         
            sprintf( buf, "Diode index (%d) outside range of BPM structure in load_bpmconf(...)",
                     (*conf)[bpm_temp_idx].diode_idx );
            bpm_warning(buf, __FILE__, __LINE__ );
          }
        }
        else if ( strcmp( "bpm_idx", args[iarg] ) == 0 ) {
          // ---------------------------------------------------------
          // The bpm index - already dealt with
        }
        else {
          // ---------------------------------------------------------
          // Unknown parameter
          char buf[255];
         
          sprintf( buf, "Unknown parameter (\"%s\") in bpmconf structure", args[iarg]);
            bpm_warning(buf, __FILE__, __LINE__ );
          }
        
        // Free the memory - This causes a invalid pointer error. Don't know why as yet
        //free( arg[iarg] );
        //free( arg_val[iarg] );
      }
      
      free( args );
      free( arg_val );
  }
  
  return BPM_SUCCESS;
}

---