makefakedata_v4.c

Go to the documentation of this file.

/*
*  Copyright (C) 2008 Chris Messenger, Karl Wette
*  Copyright (C) 2007 Badri Krishnan, Reinhard Prix
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with with program; see the file COPYING. If not, write to the
*  Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA  02111-1307  USA
*/

/*-----------------------------------------------------------------------
 *
 * File Name: makefakedata_v4.c
 *
 * Authors: R. Prix, M.A. Papa, X. Siemens, B. Allen, C. Messenger
 *
 * This code is a descendant of an earlier implementation 'makefakedata_v2.[ch]'
 * by Badri Krishnan, Bruce Allen, Maria Alessandra Papa, Reinhard Prix, Xavier Siemens, Yousuke Itoh
 *
 * Revision: $Id: makefakedata_v4.c,v 1.100 2008/10/01 16:38:49 reinhard Exp $
 *
 *
 *-----------------------------------------------------------------------
 */

/* ---------- includes ---------- */
#include <sys/stat.h>

#include <lalapps.h>
#include <lal/AVFactories.h>
#include <lal/SeqFactories.h>
#include <lal/LALInitBarycenter.h>
#include <lal/Random.h>
#include <gsl/gsl_math.h>

#include <lal/UserInput.h>
#include <lal/SFTfileIO.h>
#include <lal/GeneratePulsarSignal.h>
#include <lal/TimeSeries.h>
#include <lal/BinaryPulsarTiming.h>
#include <lal/Window.h>

#include <lal/lalGitID.h>
#include <lalappsGitID.h>


RCSID ("$Id: makefakedata_v4.c,v 1.100 2008/10/01 16:38:49 reinhard Exp $");

/* Error codes and messages */
/* <lalErrTable file="MAKEFAKEDATACErrorTable"> */
#define MAKEFAKEDATAC_ENORM     0
#define MAKEFAKEDATAC_ESUB      1
#define MAKEFAKEDATAC_EARG      2
#define MAKEFAKEDATAC_EBAD      3
#define MAKEFAKEDATAC_EFILE     4
#define MAKEFAKEDATAC_ENOARG    5
#define MAKEFAKEDATAC_EMEM      6
#define MAKEFAKEDATAC_EBINARYOUT 7
#define MAKEFAKEDATAC_EREADFILE 8

#define MAKEFAKEDATAC_MSGENORM "Normal exit"
#define MAKEFAKEDATAC_MSGESUB  "Subroutine failed"
#define MAKEFAKEDATAC_MSGEARG  "Error parsing arguments"
#define MAKEFAKEDATAC_MSGEBAD  "Bad argument values"
#define MAKEFAKEDATAC_MSGEFILE "File IO error"
#define MAKEFAKEDATAC_MSGENOARG "Missing argument"
#define MAKEFAKEDATAC_MSGEMEM   "Out of memory..."
#define MAKEFAKEDATAC_MSGEBINARYOUT "Error in writing binary-data to stdout"
#define MAKEFAKEDATAC_MSGEREADFILE "Error reading in file"
/* </lalErrTable> */

/***************************************************/
#define TRUE (1==1)
#define FALSE (1==0)

#define myMax(x,y) ( (x) > (y) ? (x) : (y) )
#define SQ(x) ( (x) * (x) )
#define GPS2REAL(gps) (gps.gpsSeconds + 1e-9 * gps.gpsNanoSeconds )

/*----------------------------------------------------------------------*/
/** configuration-variables derived from user-variables */
typedef struct
{
  PulsarParams pulsar;          /**< pulsar signal-parameters (amplitude + doppler */
  EphemerisData edat;           /**< ephemeris-data */
  LALDetector site;             /**< detector-site info */

  LIGOTimeGPS startTimeGPS;     /**< start-time of observation */
  UINT4 duration;               /**< total duration of observation in seconds */

  LIGOTimeGPSVector *timestamps;/**< a vector of timestamps to generate time-series/SFTs for */

  REAL8 fmin_eff;               /**< 'effective' fmin: round down such that fmin*Tsft = integer! */
  REAL8 fBand_eff;              /**< 'effective' frequency-band such that samples/SFT is integer */
  REAL8Vector *spindown;        /**< vector of frequency-derivatives of GW signal */

  SFTVector *noiseSFTs;         /**< vector of noise-SFTs to be added to signal */
  REAL8 noiseSigma;             /**< sigma for Gaussian noise to be added */

  REAL4Window *window;          /**< window function for the time series */

  COMPLEX8FrequencySeries *transfer;  /**< detector's transfer function for use in hardware-injection */

  INT4 randSeed;                /**< random-number seed: either taken from user or /dev/urandom */
} ConfigVars_t;

/** Default year-span of ephemeris-files to be used */
#define EPHEM_YEARS  "00-04"

/* ---------- local prototypes ---------- */
void FreeMem (LALStatus *, ConfigVars_t *cfg);
void InitUserVars (LALStatus *);
void InitMakefakedata (LALStatus *, ConfigVars_t *cfg, int argc, char *argv[]);
void AddGaussianNoise (LALStatus *, REAL4TimeSeries *outSeries, REAL4TimeSeries *inSeries, REAL4 sigma, INT4 seed);
/* void GetOrbitalParams (LALStatus *, BinaryOrbitParams *orbit); */
void WriteMFDlog (LALStatus *, char *argv[], const char *logfile);


void LoadTransferFunctionFromActuation(LALStatus *,
                                       COMPLEX8FrequencySeries **transfer,
                                       REAL8 actuationScale,
                                       const CHAR *fname);

void LALExtractSFTBand ( LALStatus *, SFTVector **outSFTs, const SFTVector *inSFTs, REAL8 fmin, REAL8 Band );

void LALGenerateLineFeature ( LALStatus *status, REAL4TimeSeries **Tseries, const PulsarSignalParams *params );

extern void write_timeSeriesR4 (FILE *fp, const REAL4TimeSeries *series);
extern void write_timeSeriesR8 (FILE *fp, const REAL8TimeSeries *series);
BOOLEAN is_directory ( const CHAR *fname );
void OutputVersion ( void );

/*----------------------------------------------------------------------*/
static const ConfigVars_t empty_GV;
static const LALUnit empty_LALUnit;
/*----------------------------------------------------------------------*/
/* User variables */
/*----------------------------------------------------------------------*/
BOOLEAN uvar_help;              /**< Print this help/usage message */

/* output */
CHAR *uvar_outSFTbname;         /**< Path and basefilename of output SFT files */
BOOLEAN uvar_outSFTv1;          /**< use v1-spec for output-SFTs */

CHAR *uvar_TDDfile;             /**< Filename for ASCII output time-series */
BOOLEAN uvar_hardwareTDD;       /**< Binary output timeseries in chunks of Tsft for hardware injections. */

CHAR *uvar_logfile;             /**< name of logfile */

/* specify start + duration */
CHAR *uvar_timestampsFile;      /**< Timestamps file */
INT4 uvar_startTime;            /**< Start-time of requested signal in detector-frame (GPS seconds) */
INT4 uvar_duration;             /**< Duration of requested signal in seconds */

/* generation mode of timer-series: all-at-once or per-sft */
INT4 uvar_generationMode;       /**< How to generate the timeseries: all-at-once or per-sft */
typedef enum
  {
    GENERATE_ALL_AT_ONCE = 0,   /**< generate whole time-series at once before turning into SFTs */
    GENERATE_PER_SFT,           /**< generate timeseries individually for each SFT */
    GENERATE_LAST               /**< end-marker */
  } GenerationMode;

/* time-series sampling + heterodyning frequencies */
REAL8 uvar_fmin;                /**< Lowest frequency in output SFT (= heterodyning frequency) */
REAL8 uvar_Band;                /**< bandwidth of output SFT in Hz (= 1/2 sampling frequency) */

/* SFT params */
REAL8 uvar_Tsft;                /**< SFT time baseline Tsft */
REAL8 uvar_SFToverlap;          /**< overlap SFTs by this many seconds */

/* noise to add [OPTIONAL] */
CHAR *uvar_noiseSFTs;           /**< Glob-like pattern specifying noise-SFTs to be added to signal */
REAL8 uvar_noiseSigma;          /**< Gaussian noise with standard-deviation sigma */
REAL8 uvar_noiseSqrtSh;         /**< ALTERNATIVE: single-sided sqrt(Sh) for Gaussian noise */

/* Window function [OPTIONAL] */
CHAR *uvar_window;              /**< Windowing function for the time series */

/* Detector and ephemeris */
CHAR *uvar_IFO;                 /**< Detector: H1, L1, H2, V1, ... */
CHAR *uvar_detector;            /**< [DEPRECATED] Detector: LHO, LLO, VIRGO, GEO, TAMA, CIT, ROME */

CHAR *uvar_actuation;           /**< filename containg detector actuation function */
REAL8 uvar_actuationScale;      /**< Scale-factor to be applied to actuation-function */
CHAR *uvar_ephemDir;            /**< Directory path for ephemeris files (optional), use LAL_DATA_PATH if unset. */
CHAR *uvar_ephemYear;           /**< Year (or range of years) of ephemeris files to be used */

/* pulsar parameters [REQUIRED] */
REAL8 uvar_refTime;             /**< Pulsar reference time tRef in SSB ('0' means: use startTime converted to SSB) */
REAL8 uvar_refTimeMJD;          /**< Pulsar reference time tRef in MJD ('0' means: use startTime converted to SSB) */

REAL8 uvar_h0;                  /**< overall signal amplitude h0 */
REAL8 uvar_cosi;                /**< cos(iota) of inclination angle iota */
REAL8 uvar_aPlus;               /**< ALTERNATIVE to {h0,cosi}: Plus polarization amplitude aPlus */
REAL8 uvar_aCross;              /**< ALTERNATIVE to {h0,cosi}: Cross polarization amplitude aCross */
REAL8 uvar_psi;                 /**< Polarization angle psi */
REAL8 uvar_phi0;                /**< Initial phase phi */

REAL8 uvar_Alpha;               /**< Right ascension [radians] alpha of pulsar */
REAL8 uvar_Delta;               /**< Declination [radians] delta of pulsar */
CHAR *uvar_RA;                  /**< Right ascension [hh:mm:ss.ssss] alpha of pulsar */
CHAR *uvar_Dec;                 /**< Declination [dd:mm:ss.ssss] delta of pulsar */
REAL8 uvar_longitude;           /**< [DEPRECATED] Right ascension [radians] alpha of pulsar */
REAL8 uvar_latitude;            /**< [DEPRECATED] Declination [radians] delta of pulsar */

REAL8 uvar_Freq;
REAL8 uvar_f0;                  /**< [DEPRECATED] Gravitational wave-frequency f0 at refTime */

REAL8 uvar_f1dot;               /**< First spindown parameter f' */
REAL8 uvar_f2dot;               /**< Second spindown parameter f'' */
REAL8 uvar_f3dot;               /**< Third spindown parameter f''' */

/* orbital parameters [OPTIONAL] */

REAL8 uvar_orbitasini;          /**< Projected orbital semi-major axis in seconds (a/c) */
REAL8 uvar_orbitEcc;            /**< Orbital eccentricity */
INT4  uvar_orbitTpSSBsec;       /**< 'observed' (SSB) time of periapsis passage. Seconds. */
INT4  uvar_orbitTpSSBnan;       /**< 'observed' (SSB) time of periapsis passage. Nanoseconds. */
REAL8 uvar_orbitTpSSBMJD;       /**< 'observed' (SSB) time of periapsis passage. MJD. */
REAL8 uvar_orbitPeriod;         /**< Orbital period (seconds) */
REAL8 uvar_orbitArgp;           /**< Argument of periapsis (radians) */

/* precision-level of signal-generation */
BOOLEAN uvar_exactSignal;       /**< generate signal timeseries as exactly as possible (slow) */
BOOLEAN uvar_lineFeature;       /**< generate a monochromatic line instead of a pulsar-signal */

BOOLEAN uvar_version;           /**< output version information */

INT4 uvar_randSeed;             /**< allow user to specify random-number seed for reproducible noise-realizations */

/*----------------------------------------------------------------------*/

extern int vrbflg;

/*----------------------------------------------------------------------
 * main function
 *----------------------------------------------------------------------*/
int
main(int argc, char *argv[])
{
  LALStatus status = blank_status;      /* initialize status */
  ConfigVars_t GV = empty_GV;
  PulsarSignalParams params = empty_PulsarSignalParams;
  SFTVector *SFTs = NULL;
  REAL4TimeSeries *Tseries = NULL;
  UINT4 i_chunk, numchunks;

  UINT4 i;

  lalDebugLevel = 0;    /* default value */
  vrbflg = 1;           /* verbose error-messages */

  /* set LAL error-handler */
  lal_errhandler = LAL_ERR_EXIT;        /* exit with returned status-code on error */

  /* ------------------------------
   * read user-input and set up shop
   *------------------------------*/
  LAL_CALL (LALGetDebugLevel(&status, argc, argv, 'v'), &status);

  LAL_CALL (InitMakefakedata(&status, &GV, argc, argv), &status);

  /*----------------------------------------
   * fill the PulsarSignalParams struct
   *----------------------------------------*/
  /* pulsar params */
  params.pulsar.refTime            = GV.pulsar.Doppler.refTime;
  params.pulsar.position.system    = COORDINATESYSTEM_EQUATORIAL;
  params.pulsar.position.longitude = GV.pulsar.Doppler.Alpha;
  params.pulsar.position.latitude  = GV.pulsar.Doppler.Delta;
  {
    REAL8 h0   = GV.pulsar.Amp.h0;
    REAL8 cosi = GV.pulsar.Amp.cosi;
    params.pulsar.aPlus            = 0.5 * h0 * ( 1.0 + SQ(cosi) );
    params.pulsar.aCross           = h0 * cosi;
  }
  params.pulsar.phi0               = GV.pulsar.Amp.phi0;
  params.pulsar.psi                = GV.pulsar.Amp.psi;

  params.pulsar.f0                 = GV.pulsar.Doppler.fkdot[0];
  params.pulsar.spindown           = GV.spindown;
  params.orbit                     = GV.pulsar.Doppler.orbit;

  /* detector params */
  params.transfer = GV.transfer;        /* detector transfer function (NULL if not used) */
  params.site = &(GV.site);
  params.ephemerides = &(GV.edat);

  /* characterize the output time-series */
  if ( ! uvar_exactSignal )     /* GeneratePulsarSignal() uses 'idealized heterodyning' */
    {
      params.samplingRate       = 2.0 * GV.fBand_eff;   /* sampling rate of time-series (=2*frequency-Band) */
      params.fHeterodyne        = GV.fmin_eff;          /* heterodyning frequency for output time-series */
    }
  else  /* in the exact-signal case: don't do heterodyning, sample at least twice highest frequency */
    {
      params.samplingRate       = myMax( 2.0 * (params.pulsar.f0 + 2 ), 2*(GV.fmin_eff + GV.fBand_eff ) );
      params.fHeterodyne        = 0;
    }

  /* set-up main-loop according to 'generation-mode' (all-at-once' or 'per-sft') */
  switch ( uvar_generationMode )
    {
    case GENERATE_ALL_AT_ONCE:
      params.duration     = GV.duration;
      numchunks = 1;
      break;
    case GENERATE_PER_SFT:
      params.duration = (UINT4) ceil(uvar_Tsft);
      numchunks = GV.timestamps->length;
      break;
    default:
      printf ("\nIllegal value for generationMode %d\n\n", uvar_generationMode);
      return MAKEFAKEDATAC_EARG;
      break;
    } /* switch generationMode */

  /* ----------
   * Main loop: produce time-series and turn it into SFTs,
   * either all-at-once or per-sft
   * ----------*/
  for ( i_chunk = 0; i_chunk < numchunks; i_chunk++ )
    {
      params.startTimeGPS = GV.timestamps->data[i_chunk];

      /*----------------------------------------
       * generate the signal time-series
       *----------------------------------------*/
      if ( uvar_exactSignal )
        {
          LAL_CALL ( LALSimulateExactPulsarSignal (&status, &Tseries, &params), &status );
        }
      else if ( uvar_lineFeature )
        {
          LAL_CALL ( LALGenerateLineFeature ( &status, &Tseries, &params ), &status );
        }
      else
        {
          LAL_CALL ( LALGeneratePulsarSignal(&status, &Tseries, &params), &status );
        }

      /* for HARDWARE-INJECTION:
       * before the first chunk we send magic number and chunk-length to stdout
       */
      if ( uvar_hardwareTDD && (i_chunk == 0) )
        {
          REAL4 magic = 1234.5;
          UINT4 length = Tseries->data->length;
          if ( (1 != fwrite ( &magic, sizeof(magic), 1, stdout ))
               || (1 != fwrite(&length, sizeof(INT4), 1, stdout)) )
            {
              perror ("Failed to write to stdout");
              exit (MAKEFAKEDATAC_EFILE);
            }
        } /* if hardware-injection and doing first chunk */


      /* add Gaussian noise if requested */
      if ( GV.noiseSigma > 0) {
        LAL_CALL ( AddGaussianNoise(&status, Tseries, Tseries, (REAL4)(GV.noiseSigma), GV.randSeed ), &status);
      }

      /* output ASCII time-series if requested */
      if ( uvar_TDDfile )
        {
          FILE *fp;
          CHAR *fname = LALCalloc (1, strlen(uvar_TDDfile) + 10 );
          sprintf (fname, "%s.%02d", uvar_TDDfile, i_chunk);

          if ( (fp = fopen (fname, "w")) == NULL)
            {
              perror ("Error opening outTDDfile for writing");
              printf ("TDDfile = %s\n", fname );
              exit ( MAKEFAKEDATAC_EFILE );
            }

          write_timeSeriesR4(fp, Tseries);
          fclose(fp);
          LALFree (fname);
        } /* if outputting ASCII time-series */


      /* if hardware injection: send timeseries in binary-format to stdout */
      if ( uvar_hardwareTDD )
        {
          UINT4  length = Tseries->data->length;
          REAL4 *datap = Tseries->data->data;

          if ( length != fwrite (datap, sizeof(datap[0]), length, stdout) )
            {
              perror( "Fatal error in writing binary data to stdout\n");
              exit (MAKEFAKEDATAC_EBINARYOUT);
            }
          fflush (stdout);

        } /* if hardware injections */

      /*----------------------------------------
       * last step: turn this timeseries into SFTs
       * and output them to disk
       *----------------------------------------*/
      if (uvar_outSFTbname)
        {
          SFTParams sftParams = empty_SFTParams;
          LIGOTimeGPSVector ts;
          SFTVector noise;

          sftParams.Tsft = uvar_Tsft;
          sftParams.make_v2SFTs = 1;

          switch (uvar_generationMode)
            {
            case GENERATE_ALL_AT_ONCE:
              sftParams.timestamps = GV.timestamps;
              sftParams.noiseSFTs = GV.noiseSFTs;
              break;
            case GENERATE_PER_SFT:
              ts.length = 1;
              ts.data = &(GV.timestamps->data[i_chunk]);
              sftParams.timestamps = &(ts);
              sftParams.noiseSFTs = NULL;

              if ( GV.noiseSFTs )
                {
                  noise.length = 1;
                  noise.data = &(GV.noiseSFTs->data[i_chunk]);
                  sftParams.noiseSFTs = &(noise);
                }

              break;

            default:
              printf ("\ninvalid Value for --generationMode\n\n");
              return MAKEFAKEDATAC_EBAD;
              break;
            }

          /* Enter the window function into the SFTparams struct */
          sftParams.window = GV.window;

          /* get SFTs from timeseries */
          LAL_CALL ( LALSignalToSFTs(&status, &SFTs, Tseries, &sftParams), &status);

          /* extract requested band if necessary (eg in the exact-signal case) */
          if ( uvar_exactSignal )
            {
              SFTVector *outSFTs = NULL;
              LAL_CALL ( LALExtractSFTBand ( &status, &outSFTs, SFTs, GV.fmin_eff, GV.fBand_eff ), &status );
              LAL_CALL ( LALDestroySFTVector ( &status, &SFTs ), &status );
              SFTs = outSFTs;
            }

          if ( uvar_outSFTv1 )          /* write output-SFTs using the SFT-v1 format */
            {
              CHAR *fname = LALCalloc (1, strlen (uvar_outSFTbname) + 10);

              for (i=0; i < SFTs->length; i++)
                {
                  sprintf (fname, "%s.%05d", uvar_outSFTbname, i_chunk*SFTs->length + i);
                  LAL_CALL ( LALWrite_v2SFT_to_v1file ( &status, &(SFTs->data[i]), fname ), &status );
                }
              LALFree (fname);
            } /* if outSFTv1 */
          else
            {   /* write standard v2-SFTs */
              CHAR *comment = NULL;
              CHAR *logstr = NULL;

              /* check that user didn't follow v1-habits and tried to give us a base filename */
              if ( ! is_directory ( uvar_outSFTbname ) )
                {
                  fprintf (stderr, "\nERROR: the --outSFTbname '%s' is not a directory!\n", uvar_outSFTbname);
                  fprintf (stderr, "------------------------------------------------------------\n");
                  fprintf (stderr, "NOTE: v2-SFTs are written using the SFTv2 filename-convention!\n");
                  fprintf (stderr, "==> therefore, only an (existing) directory-name may be given to --outSFTbname, but no basename!\n");
                  fprintf (stderr, "------------------------------------------------------------\n\n");
                  return MAKEFAKEDATAC_EBAD;
                }
              LAL_CALL ( LALUserVarGetLog ( &status, &logstr,  UVAR_LOGFMT_CMDLINE ), &status );
              comment = LALCalloc ( 1, strlen ( logstr ) + strlen(lalGitID) + strlen(lalappsGitID) + 512 );
              sprintf ( comment, "Generated by $Id: makefakedata_v4.c,v 1.100 2008/10/01 16:38:49 reinhard Exp $:\n%s\n%s\n%s", logstr, lalGitID, lalappsGitID );
              LAL_CALL ( LALWriteSFTVector2Dir (&status, SFTs, uvar_outSFTbname, comment, "mfdv4" ), &status );
              LALFree ( logstr );
              LALFree ( comment );
            }
        } /* if outSFTbname */

      /* free memory */
      if (Tseries)
        {
          LAL_CALL (LALDestroyVector(&status, &(Tseries->data)), &status);
          LALFree (Tseries);
          Tseries = NULL;
        }

      if (SFTs)
        {
          LAL_CALL (LALDestroySFTVector(&status, &SFTs), &status);
          SFTs = NULL;
        }

    } /* for i_chunk < numchunks */

  LAL_CALL (FreeMem(&status, &GV), &status);    /* free the rest */

  LALCheckMemoryLeaks();

  return 0;
} /* main */

/**
 *  Handle user-input and set up shop accordingly, and do all
 * consistency-checks on user-input.
 */
void
InitMakefakedata (LALStatus *status, ConfigVars_t *cfg, int argc, char *argv[])
{
  CHAR *channelName = NULL;

  INITSTATUS( status, "InitMakefakedata", rcsid );
  ATTATCHSTATUSPTR (status);

  /* register all user-variables */
  TRY (InitUserVars(status->statusPtr), status);

  /* read cmdline & cfgfile  */
  TRY (LALUserVarReadAllInput(status->statusPtr, argc,argv), status);

  if (uvar_help)        /* if help was requested, we're done */
    exit (0);

  if ( uvar_version )
    {
      OutputVersion();
      exit (0);
    }

  /* if requested, log all user-input and code-versions */
  if ( uvar_logfile ) {
    TRY ( WriteMFDlog(status->statusPtr, argv, uvar_logfile), status);
  }

  { /* ========== translate user-input into 'PulsarParams' struct ========== */
    BOOLEAN have_h0     = LALUserVarWasSet ( &uvar_h0 );
    BOOLEAN have_cosi   = LALUserVarWasSet ( &uvar_cosi );
    BOOLEAN have_aPlus  = LALUserVarWasSet ( &uvar_aPlus );
    BOOLEAN have_aCross = LALUserVarWasSet ( &uvar_aCross );
    BOOLEAN have_Freq   = LALUserVarWasSet ( &uvar_Freq );
    BOOLEAN have_f0     = LALUserVarWasSet ( &uvar_f0 );
    BOOLEAN have_longitude = LALUserVarWasSet ( &uvar_longitude );
    BOOLEAN have_latitude  = LALUserVarWasSet ( &uvar_latitude );
    BOOLEAN have_Alpha  = LALUserVarWasSet ( &uvar_Alpha );
    BOOLEAN have_Delta  = LALUserVarWasSet ( &uvar_Delta );
    BOOLEAN have_RA = LALUserVarWasSet ( &uvar_RA );
    BOOLEAN have_Dec = LALUserVarWasSet ( &uvar_Dec );

    /* ----- {h0,cosi} or {aPlus,aCross} ----- */
    if ( (have_aPlus || have_aCross) && ( have_h0 || have_cosi ) ) {
      printf ( "\nSpecify EITHER {h0,cosi} OR {aPlus, aCross}!\n\n");
      ABORT (status,  MAKEFAKEDATAC_EBAD,  MAKEFAKEDATAC_MSGEBAD);
    }
    if ( (have_h0 ^ have_cosi) ) {
      printf ( "\nNeed both --h0 and --cosi!\n\n");
      ABORT (status,  MAKEFAKEDATAC_EBAD,  MAKEFAKEDATAC_MSGEBAD);
    }
    if ( (have_aPlus ^ have_aCross) ) {
      printf ( "\nNeed both --aPlus and --aCross !\n\n");
      ABORT (status,  MAKEFAKEDATAC_EBAD,  MAKEFAKEDATAC_MSGEBAD);
    }
    if ( have_h0 && have_cosi )
      {
        cfg->pulsar.Amp.h0 = uvar_h0;
        cfg->pulsar.Amp.cosi = uvar_cosi;
      }
    else if ( have_aPlus && have_aCross )
      {  /* translate A_{+,x} into {h_0, cosi} */
        REAL8 disc;
        if ( fabs(uvar_aCross) > uvar_aPlus )
          {
            printf ( "\nInvalid input parameters: aCross must smaller or equal aPlus !\n\n");
            ABORT (status,  MAKEFAKEDATAC_EBAD,  MAKEFAKEDATAC_MSGEBAD);
          }
        disc = sqrt ( SQ(uvar_aPlus) - SQ(uvar_aCross) );
        cfg->pulsar.Amp.h0   = uvar_aPlus + disc;
        cfg->pulsar.Amp.cosi = uvar_aCross / cfg->pulsar.Amp.h0;
      }
    else {
      cfg->pulsar.Amp.h0 = 0.0;
      cfg->pulsar.Amp.cosi = 0.0;
    }
    cfg->pulsar.Amp.phi0 = uvar_phi0;
    cfg->pulsar.Amp.psi  = uvar_psi;
    /* ----- signal Frequency ----- */
    if ( have_f0 && have_Freq ) {
      printf ( "\nSpecify signal-frequency using EITHER --Freq [preferred] OR --f0 [deprecated]!\n\n");
      ABORT (status,  MAKEFAKEDATAC_EBAD,  MAKEFAKEDATAC_MSGEBAD);
    }
    if ( have_Freq )
      cfg->pulsar.Doppler.fkdot[0] = uvar_Freq;
    else if ( have_f0 )
      cfg->pulsar.Doppler.fkdot[0] = uvar_f0;
    else
      cfg->pulsar.Doppler.fkdot[0] = 0.0;

    /* ----- skypos ----- */
    if ( (have_Alpha || have_Delta) && ( have_longitude || have_latitude ) && (have_RA || have_Dec) ) {
      printf ( "\nUse EITHER {Alpha, Delta} [preferred] OR {RA, Dec} [preferred] OR {longitude,latitude} [deprecated]\n\n");
      ABORT (status,  MAKEFAKEDATAC_EBAD,  MAKEFAKEDATAC_MSGEBAD);
    }
    if ( (have_Alpha && !have_Delta) || ( !have_Alpha && have_Delta ) ) {
      printf ( "\nSpecify skyposition: need BOTH --Alpha and --Delta!\n\n");
      ABORT (status,  MAKEFAKEDATAC_EBAD,  MAKEFAKEDATAC_MSGEBAD);
    }
    if ( (have_longitude && !have_latitude) || ( !have_longitude && have_latitude ) ) {
      printf ( "\nSpecify skyposition: need BOTH --longitude and --latitude!\n\n");
      ABORT (status,  MAKEFAKEDATAC_EBAD,  MAKEFAKEDATAC_MSGEBAD);
    }
    if ( (have_RA && !have_Dec) || ( !have_RA && have_Dec ) ) {
      printf ( "\nSpecify skyposition: need BOTH --RA and --Dec!\n\n");
      ABORT (status,  MAKEFAKEDATAC_EBAD,  MAKEFAKEDATAC_MSGEBAD);
    }
    if