main.c

/* Copyright (c) Anglo-Australian Telescope Board, 1999.
   Not to be used for commercial purposes without AATB permission. */


#include "DitsFix.h"
#include "Sdp.h"
#include "Git.h"
#include "dul_err.h"
#include "drs_err.h" 

/* globals */
/* string containing drexec version */
char versionStr[128];

/* externals */
extern void combine_image_(DitsArgType*,StatusType*);
extern void combine_spectra_(DitsArgType*,StatusType*);
/* extern void flx_calib_(DitsArgType*,StatusType*); */
/* extern void gen_calib_(DitsArgType*,StatusType*); */
extern void cmfim_gfibpos_(DitsArgType*,StatusType*);
extern void plot_file_(DitsArgType*,StatusType*);
extern void plotserver_(DitsArgType*,DitsArgType*,StatusType*);
extern void reduce_arc_(DitsArgType*,StatusType*);
extern void reduce_bias_(DitsArgType*,StatusType*);
extern void reduce_dark_(DitsArgType*,StatusType*);
extern void reduce_fflat_(DitsArgType*,StatusType*);
extern void reduce_lflat_(DitsArgType*,StatusType*);
extern void reduce_fflx_(DitsArgType*,StatusType*);
extern void reduce_object_(DitsArgType*,StatusType*);
extern void reduce_sky_(DitsArgType*,StatusType*);
extern void reduce_gen(DitsArgType*,StatusType*);
extern void make_im___(DitsArgType*,StatusType*);
extern void make_ex_(DitsArgType*,StatusType*);
extern void make_red_(DitsArgType*,StatusType*);
extern void skysub_pca_(DitsArgType*,StatusType*);
extern void splice_aaomega_(DitsArgType*,StatusType*);
extern void detect_cosmic_streaks_(DitsArgType*,StatusType*);
extern void transfer_function_correction_(DitsArgType*,StatusType*);

/* forward declarations */
static void changeWorkingDirectory(StatusType*);
static void combineImageAction(StatusType*);
static void combineSpectraAction(StatusType*);
/* static void flxCalibAction(StatusType*); */
/* static void genCalibAction(StatusType*); */
static void find2dfFibresAction(StatusType*);
static void plotAction(StatusType*);
static void plotKick(StatusType*);
static void reduceArcAction(StatusType*);
static void reduceBiasAction(StatusType*);
static void reduceDarkAction(StatusType*);
static void reduceFFlatAction(StatusType*);
static void reduceLFlatAction(StatusType*);
static void reduceFFluxAction(StatusType*);
static void reduceObjAction(StatusType*);
static void reduceSkyAction(StatusType*);
static void reduceGenAction(StatusType*);
static void makeIMAction(StatusType*);
static void makeEXAction(StatusType*);
static void makeREDAction(StatusType*);
static void skysubPCAAction(StatusType*);
static void spliceAction(StatusType*);
static void transfuncAction(StatusType*);
static void detectCosmicStreaksAction(StatusType*);
static void exitAction(StatusType*);
static void testAction(StatusType*);
static void testKick(StatusType*);
static void NOPAction(StatusType*);
void SetPgplotRequest(char key, float x, float y);
void GetPgplotRequest(char* key, float* x, float* y);


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

int main(int argc,char** argv)
/*
 * Execution of drexec server DRAMA task begins here.
 *
 * This task acts as an action server for 2dfdr. drcontrol acts as the client
 * DRAMA task sending this task requests for 2dfdr processing.
 *
 * N.B. This task BREAKS one of the cardinal rules of DRAMA -
 *      1. Tasks accepting and servicing actions shall reschedule immediately
 *         thereby being ready for any new actions (or kicks).
 *      Notice the DRAMA actions served by this task are quite CPU intensive,
 *      and the program does NOT reschedule until they complete.
 */
{
    StatusType status = DITS__OK;
    char taskName[40];

    /* this task executes following DRAMA actions */
    DitsActionDetailsType actions[] = {
	{ changeWorkingDirectory,     0,0,0,0,0,"CHANGE_WD"         },
	{ combineImageAction,  plotKick,0,0,0,0,"COMBINE_IMAGE"     },
	{ combineSpectraAction,plotKick,0,0,0,0,"COMBINE_SPECTRA"   },
	{ find2dfFibresAction, plotKick,0,0,0,0,"GFIBPOS"           },
	{ plotAction,          plotKick,0,0,0,0,"PLOT"              },
	{ reduceArcAction,     plotKick,0,0,0,0,"REDUCE_ARC"        },
	{ reduceBiasAction,    plotKick,0,0,0,0,"REDUCE_BIAS"       },
	{ reduceDarkAction,    plotKick,0,0,0,0,"REDUCE_DARK"       },
	{ reduceFFlatAction,   plotKick,0,0,0,0,"REDUCE_FFLAT"      },
	{ reduceLFlatAction,   plotKick,0,0,0,0,"REDUCE_LFLAT"      },
	{ reduceFFluxAction,   plotKick,0,0,0,0,"REDUCE_FFLX"       },
	{ reduceObjAction,     plotKick,0,0,0,0,"REDUCE_OBJECT"     },
	{ reduceSkyAction,     plotKick,0,0,0,0,"REDUCE_SKY"        },
	{ reduceGenAction,     plotKick,0,0,0,0,"REDUCE_GEN"        },
	{ makeIMAction,        plotKick,0,0,0,0,"MAKE_IM"           },
	{ makeEXAction,        plotKick,0,0,0,0,"MAKE_EX"           },
	{ makeREDAction,       plotKick,0,0,0,0,"MAKE_RED"          },
	{ skysubPCAAction,     plotKick,0,0,0,0,"SKYSUB_PCA"        },
	{ spliceAction,        plotKick,0,0,0,0,"SPLICE"            },
	{ transfuncAction,     plotKick,0,0,0,0,"TRANSFUNC"         },
	{ detectCosmicStreaksAction,plotKick,0,0,0,0,"DETECT_CSTRKS"},
	{ exitAction,          0,       0,0,0,0,"EXIT"              },
	{ NOPAction,           plotKick,       0,0,0,0,"NOP"               },
        { testAction,          plotKick,0,0,0,0,"TEST"              }
    };

    /* The task name is normally given in argv[1]. Multiple copies of the
       task can  be started using different task names. A default name is
       used if one is not given. */
    strcpy(taskName,(argc > 1) ? argv[1] : "DREXEC");
 
    /* initialise DRAMA
       DITS_M_NOEXHAND => we will install exit handler */
    DitsAppInit(taskName,300000,DITS_M_NOEXHAND,0,&status);

    /* define supported actions */
    DitsPutActions(DitsNumber(actions),actions,&status);  

    /* enter DRAMA main loop
       This returns when action returns DITS_REQ_EXIT */
    DitsMainLoop(&status);

     /* here returned from DRAMA main loop, shutdown DRAMA and exit */
    return DitsStop(taskName,&status);
}

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

void NOPAction(
    StatusType* pStatus)
/*
 * Handler for "No Operation" DRAMA action (i.e. do nothing).
 */
{
    if (*pStatus != DITS__OK) return;

    printf("   +++NOP Action++++ Status=%i\n",*pStatus);
    sleep(1*60);
    printf("   +++NOP Finished++ Status=%i\n",*pStatus);

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void changeWorkingDirectory(
    StatusType* pStatus)
/*
 * Handler for "CHANGE_WD" DRAMA action.
 */
{
    DitsArgType args;
    long len;
    char dirname[1024];
    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();
  
    /* Get the name of the new working directory from the SDS arg*/
    len=1024;
    ArgGetString(args, "NEW_WORK_DIR", len, dirname, pStatus);

    /* Change the working directory to the new location*/
    chdir(dirname);

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void combineImageAction(
    StatusType* pStatus)
/*
 * Handler for "COMBINE_IMAGE" DRAMA action.
 */
{
    DitsArgType args;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus); /*

    /* call Fortran COMBINE_IMAGE() */
    combine_image_(&args,pStatus);

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void combineSpectraAction(
    StatusType* pStatus)
/*
 * Handler for "COMBINE_SPECTRA" DRAMA action.
 */
{
    DitsArgType args;

    if (*pStatus != DITS__OK) return;
    
    /* get our SDS argument structure */
    args = DitsGetArgument();
    
    /* Dump arguments list to screen for diagnostic purposes */
    /*SdsList(args,pStatus);*/
    
    /* call Fortran COMBINE_SPECTRA() */
    combine_spectra_(&args,pStatus);
    
    DitsPutRequest(DITS_REQ_END,pStatus);
    
}

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

void flxCalibAction(
    StatusType* pStatus)
/*
 * Handler for "FLX_CALIB" DRAMA action.
 *
 * This action is not currently working. See flux_cal.f.
 */
{
    DitsArgType args;
/*    SdsIdType localArgs; */

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus); */

    /* make copy so it can be changed (external SDS -> internal) */
 /*    SdsCopy(args,&localArgs,pStatus); */

    /* call Fortran and ???() */
/*    flx_calib_(&args,pStatus); */

    /* delete local SDS copy */
/*    SdsDelete(localArgs,pStatus); */

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void genCalibAction(
    StatusType* pStatus)
/*
 * Handler for "GEN_CALIB" DRAMA action.
 *
 * This action is not currently working. See flux_cal.f.
 */
{
    DitsArgType args;
/*    SdsIdType localArgs; */

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout 
    SdsList(args,pStatus);*/

    /* make copy so it can be changed (external SDS -> internal) */
 /*    SdsCopy(args,&localArgs,pStatus); */

    /* call Fortran and ???() */
/*    gen_calib_(&args,pStatus); */

    /* delete local SDS copy */
/*    SdsDelete(localArgs,pStatus); */

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void find2dfFibresAction(
    StatusType* pStatus)
/*
 * Handler for "GFIBPOS" (find 2df fibre positions) DRAMA action.
 *
 * This action is not currently working. See find_fib_2df.f.
 */
{
    DitsArgType args;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout 
    SdsList(args,pStatus);*/


    /* call Fortran CMFIM_GFIBPOS() */
/*    cmfim_gfibpos_(&args,pStatus); */

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void plotAction(
    StatusType* pStatus)
/*
 * Handler for "PLOT" DRAMA action.
 */
{
    DitsArgType args;
    SdsIdType inpArgs, outArgs;
    SdsIdType id2;


    if (*pStatus != DITS__OK) return;

    /* Get our input SDS argument structure */
    /* Note: This is an external SDS object and cannot be modified*/
    args = DitsGetArgument();

    SdsCopy(args,&inpArgs,pStatus);
    
    /* Create a return sds object that can be written to*/
    SdsNew(0,"retArgs",0,NULL,SDS_STRUCT,0,NULL,&outArgs,pStatus);

    /* call the Fortran subroutine plotSERVER() */
    plotserver_(&inpArgs,&outArgs,pStatus);

    /* Set the return SDS object to be outArgs*/
    DitsPutArgument (outArgs,DITS_ARG_DELETE, pStatus);
 
    DitsPutRequest(DITS_REQ_END,pStatus);

}

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

void plotKick(
    StatusType *pStatus)
/*
 * Handler for kicking the "Plot" DRAMA action.
 */
{
    DitsArgType args;
    char key;
    char Buffer[10];
    float x,y;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();
    
    /* Obtain the KEY character and the X Y values*/    
       /* Note: ArgGetc(args,"KEY",&key,pStatus) doesn't appear to work so
                we use ArgGetString instead                                */
    ArgGetString(args,"KEY",10,Buffer,pStatus);
    key=Buffer[0];
    ArgGetf(args,"X",&x,pStatus);
    ArgGetf(args,"Y",&y,pStatus);  

    /* Store these values with Pgplot Request Set Functions*/
    SetPgplotRequest(key,x,y);

    /* Now this is the bit I am not sure about but is supposed to unblock
       the DitsActionWait command */
    DitsPutRequest(DITS_REQ_STAGE,pStatus); 

}

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

void reduceArcAction(
    StatusType* pStatus)
/*
 * Handler for "REDUCE_ARC" DRAMA action.
 */
{
    DitsArgType args;
    SdsIdType localArgs = 0;
    StatusType ignore = STATUS__OK;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus);*/

    /* make copy so it can be changed (external SDS -> internal) */
    SdsCopy(args,&localArgs,pStatus);

    /* call Fortran REDUCE_ARC() */
    reduce_arc_(&localArgs,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","reduce arc error");
    }

    /* delete local SDS copy and free id */
    SdsDelete(localArgs,&ignore);
    SdsFreeId(localArgs,&ignore);

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void reduceBiasAction(
    StatusType* pStatus)
/*
 * Handler for "REDUCE_BIAS" DRAMA action.
 */
{
    DitsArgType args;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus); */

    /* call Fortran REDUCE_BIAS() */
    reduce_bias_(&args,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","reduce bias error");
    }

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void reduceDarkAction(
    StatusType* pStatus)
/*
 * Handler for "REDUCE_DARK" DRAMA action.
 */
{
    DitsArgType args;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus); */

    /* call Fortran REDUCE_DARK() */
    reduce_dark_(&args,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","reduce dark error");
    }

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void reduceFFlatAction(
    StatusType* pStatus)
/*
 * Handler for "REDUCE_FFLAT" DRAMA action.
 */
{
    DitsArgType args;
    SdsIdType localArgs = 0;
    StatusType ignore = STATUS__OK;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus); */

    /* make copy so it can be changed (external SDS -> internal) */
    SdsCopy(args,&localArgs,pStatus);

    /* call Fortran REDUCE_FFLAT() */
    reduce_fflat_(&localArgs,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","Reduce flat error");
    }

    /* delete local SDS copy and free id */
    SdsDelete(localArgs,&ignore);
    SdsFreeId(localArgs,&ignore);

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void reduceLFlatAction(
    StatusType* pStatus)
/*
 * Handler for "REDUCE_LFLAT" DRAMA action.
 */
{
    DitsArgType args;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus); */

    /* call Fortran REDUCE_LFLAT() */
    reduce_lflat_(&args,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","Reduce long flat error");
    }

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void reduceFFluxAction(
    StatusType* pStatus)
/*
 * Handler for "REDUCE_FFLX" DRAMA action.
 */
{
    DitsArgType args;
    SdsIdType localArgs = 0;
    StatusType ignore = STATUS__OK;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout*/
    /*SdsList(args,pStatus); */

    /* make copy so it can be changed (external SDS -> internal) */
    SdsCopy(args,&localArgs,pStatus);

    /* call Fortran REDUCE_OBJECT() */
    reduce_fflx_(&localArgs,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","Reduce object error");
    }

    /* delete local SDS copy and free its id*/
    SdsDelete(localArgs,&ignore);
    SdsFreeId(localArgs,&ignore);

    DitsPutRequest(DITS_REQ_END,pStatus);
}


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

void reduceObjAction(
    StatusType* pStatus)
/*
 * Handler for "REDUCE_OBJECT" DRAMA action.
 */
{
    DitsArgType args;
    SdsIdType localArgs = 0;
    StatusType ignore = STATUS__OK;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout 
    SdsList(args,pStatus); */

    /* make copy so it can be changed (external SDS -> internal) */
    SdsCopy(args,&localArgs,pStatus);

    /* call Fortran REDUCE_OBJECT() */
    reduce_object_(&localArgs,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","Reduce object error");
    }

    /* delete local SDS copy and free its id*/
    SdsDelete(localArgs,&ignore);
    SdsFreeId(localArgs,&ignore);

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void reduceSkyAction(
    StatusType* pStatus)
/*
 * Handler for "REDUCE_SKY" DRAMA action.
 */
{
    DitsArgType args;
    SdsIdType localArgs = 0;
    StatusType ignore = STATUS__OK;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus); */

    /* make copy so it can be changed (external SDS -> internal) */
    SdsCopy(args,&localArgs,pStatus);

    /* call Fortran REDUCE_SKY() */
    reduce_sky_(&localArgs,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","Reduce sky error");
    }

    /* delete local SDS copy and free its id*/
    SdsDelete(localArgs,&ignore);
    SdsFreeId(localArgs,&ignore);

    DitsPutRequest(DITS_REQ_END,pStatus);
}
/*---------------------------------------------------------------------------*/

void reduceGenAction(
    StatusType* pStatus)
/*
 * Handler for "REDUCE_GEN" DRAMA action.
 */
{
    DitsArgType args;
    SdsIdType localArgs = 0;
    StatusType ignore = STATUS__OK;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout */
    SdsList(args,pStatus);

    /* make copy so it can be changed (external SDS -> internal) */
    SdsCopy(args,&localArgs,pStatus);

    /* call Fortran REDUCE_GEN() */
    reduce_gen_(&localArgs,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","Reduce sky error");
    }

    /* delete local SDS copy and free its id*/
    SdsDelete(localArgs,&ignore);
    SdsFreeId(localArgs,&ignore);

    DitsPutRequest(DITS_REQ_END,pStatus);
}


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

void makeIMAction(
    StatusType* pStatus)
/*
 * Handler for "make_IM" DRAMA action.
 */
{
    DitsArgType args;
    SdsIdType localArgs = 0;
    StatusType ignore = STATUS__OK;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus); */

    /* make copy so it can be changed (external SDS -> internal) */
    SdsCopy(args,&localArgs,pStatus);

    /* call Fortran make_im() */
    make_im___(&localArgs,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","Make im error");
    }

    /* delete local SDS copy and free its id*/
    SdsDelete(localArgs,&ignore);
    SdsFreeId(localArgs,&ignore);

    DitsPutRequest(DITS_REQ_END,pStatus);
}
/*---------------------------------------------------------------------------*/

void makeEXAction(
    StatusType* pStatus)
/*
 * Handler for "make_IM" DRAMA action.
 */
{
    DitsArgType args;
    SdsIdType localArgs = 0;
    StatusType ignore = STATUS__OK;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus); */

    /* make copy so it can be changed (external SDS -> internal) */
    SdsCopy(args,&localArgs,pStatus);

    /* call Fortran make_ex() */
    make_ex_(&localArgs,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","Make ex error");
    }

    /* delete local SDS copy and free its id*/
    SdsDelete(localArgs,&ignore);
    SdsFreeId(localArgs,&ignore);

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void makeREDAction(
    StatusType* pStatus)
/*
 * Handler for "make_IM" DRAMA action.
 */
{
    DitsArgType args;
    SdsIdType localArgs = 0;
    StatusType ignore = STATUS__OK;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus); */

    /* make copy so it can be changed (external SDS -> internal) */
    SdsCopy(args,&localArgs,pStatus);

    /* call Fortran make_red() */
    make_red_(&localArgs,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","Make red error");
    }

    /* delete local SDS copy and free its id*/
    SdsDelete(localArgs,&ignore);
    SdsFreeId(localArgs,&ignore);

    DitsPutRequest(DITS_REQ_END,pStatus);
}
/*---------------------------------------------------------------------------*/

void skysubPCAAction(
    StatusType* pStatus)
/*
 * Handler for "make_IM" DRAMA action.
 */
{
    DitsArgType args;
    SdsIdType localArgs = 0;
    StatusType ignore = STATUS__OK;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout*/
    SdsList(args,pStatus); 

    /* make copy so it can be changed (external SDS -> internal) */
    SdsCopy(args,&localArgs,pStatus);

    /* call Fortran make_red() */
    skysub_pca_(&localArgs,pStatus);
    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","PCA Sky Subtraction error");
    }

    /* delete local SDS copy and free its id*/
    SdsDelete(localArgs,&ignore);
    SdsFreeId(localArgs,&ignore);

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void spliceAction(
    StatusType* pStatus)
/*
 * Handler for "SPLICE" DRAMA action.
 */
{
    DitsArgType args;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus); */

    /* call Fortran SPLICE_AAOMEGA() */
    splice_aaomega_(&args,pStatus);
    if (*pStatus != DITS__OK) {
        ErsRep(0,pStatus,"%s","splice error");
    }

    DitsPutRequest(DITS_REQ_END,pStatus);
}
/*---------------------------------------------------------------------------*/

void transfuncAction(
    StatusType* pStatus)
/*
 * Handler for "SPLICE" DRAMA action.
 */
{
    DitsArgType args;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout*/
    SdsList(args,pStatus); 

    /* call Fortran SPLICE_AAOMEGA() */
    transfer_function_correction_(&args,pStatus);
    if (*pStatus != DITS__OK) {
        ErsRep(0,pStatus,"%s","Tansfer Function Correction error");
    }

    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void detectCosmicStreaksAction(
    StatusType* pStatus)
/*
 * Handler for "DETECT_CSTRKS" DRAMA action.
 */
{
    DitsArgType args;
    SdsIdType localArgs = 0;
    StatusType ignore = STATUS__OK;

    if (*pStatus != DITS__OK) return;

    /* get our SDS argument structure */
    args = DitsGetArgument();

    /* for debug print our argument structure on stdout
    SdsList(args,pStatus); */

    /* make copy so it can be changed (external SDS -> internal) */
    SdsCopy(args,&localArgs,pStatus);

    /* call Fortran DETECT_COSMIC_STREAKS()  */
    detect_cosmic_streaks_(&args,pStatus);

    if (*pStatus!=DITS__OK) {
        ErsRep(0,pStatus,"%s","cosmic streak detection error error");
    }

    /* delete local SDS copy and free its id*/
    SdsDelete(localArgs,&ignore);
    SdsFreeId(localArgs,&ignore);

    DitsPutRequest(DITS_REQ_END,pStatus);
}


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

void exitAction(
    StatusType *pStatus)
/*
 * Handler for "EXIT" DRAMA action.
 */
{
    DitsPutRequest(DITS_REQ_EXIT,pStatus);
}

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

void testAction(
    StatusType *pStatus)
/*
 * Handler for "TEST" DRAMA action.
 */
{
    printf("Test Drama Action Called\n");
    DitsPutRequest(DITS_REQ_MESSAGE,pStatus);
    DitsPutRequest(DITS_REQ_END,pStatus);
}

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

void testKick(
    StatusType *pStatus)
/*
 * Handler for "TESTKICK" DRAMA action.
 */
{
    printf("Test Drama Kick Called\n");
    DitsPutRequest(DITS_REQ_END,pStatus);
}