/******************************************************************************

  File name:  jemx_shared_general.c
  Version:    see below
  Component:  
  Developer:  Peter Kretschmar, ISDC
              Peter.Kretschmar@obs.unige.ch
  
  Purpose:

  General utility functions for JEM-X data processing

*****************************************************************************/

/*
 * Revision 0.1.0  2004/01/23
 * First draft
 *
 */
#include "jemx_shared.h"

/*****************************************************************************

Function: JEMXarrayGet

Description:
      
   Set up a linear array and fill it with the data of the named child
   in the given group.
   NOTE 1: The array buffer is allocated within this function and
           must be freed in the calling function after the data has
           been mapped to some other array.
   NOTE 2: Any reformatting of the array to multiple dimensions has to
           take place in the calling function.
   Inspired by a function of C.A. Oxborrow but leaving type conversions to DAL.

Error codes:

0 == ISDC_OK   ==> function executed with no errors
< 0 (various)  ==> ISDC system function error code, passed on

Parameter arguments:
name           range         I/O     description

group          !=NULL       input   handle to instrument model group
arrayName      (string)     input   name of child to read
dataType       any          input   DAL data type of array when allocated
numAxes        >0           input   number of axes expected
dimAxes        (array)      input   dimensions of the axes
array          (array)      output  generic linear array 
chatter        0 to 5       input   verbosity control variable
callingStatus  any          input   error status on input


*****************************************************************************/
int JEMXarrayGet(dal_element     *group,
		 char            *arrayName,
		 dal_dataType     arrayType,
		 int              numAxes,
		 long            *dimAxes,
		 dal_element    **arrayPtr,
		 void           **array,
		 int              chatter,
		 int              callingStatus)
{
    /*
    *  Local variable definitions
    */
    int             status = ISDC_OK;       /* local status flag */
    dal_dataType    arrayTypeFound = DAL_DT_UNKNOWN;
    long            startRange[DAL_MAX_ARRAY_DIMENSION];
    long            dimFoundAxes[DAL_MAX_ARRAY_DIMENSION];
    long            totalDim=0, numPixels=0, bufferSize=0;
    int             i=0;
    int             numFoundAxes=0;

    /* exit function immediately if status is not OK on entry */
    if(callingStatus != ISDC_OK) return(callingStatus);
    
    /* Sanity check on dimensions */
    if (DAL_MAX_ARRAY_DIMENSION<numAxes) {
	status = JEMX_SHARED_BAD_DIMENSIONS;
   	RILlogMessage(NULL, Error_2,
		      "Error %d: DAL supports at most %d axes "
		      "but %d were requested!",
		      status,DAL_MAX_ARRAY_DIMENSION, numAxes);
   	return status ;    
    }
	
    /* Find the correct array */
    status = DALobjectFindElement(group,arrayName,arrayPtr,status);
    if (ISDC_OK!=status) {
	RILlogMessage(NULL,Error_2,
		      "Error %d searching for %s!",
		      status,arrayName);
	return(status);
    }

    /*  Get the structure of the data array. Do sanity checks  */

    status = DALarrayGetStruct(*arrayPtr,&arrayTypeFound,&numFoundAxes,
			       dimFoundAxes,status);
    if( status != ISDC_OK ){
	RILlogMessage(NULL, Error_2,
		      "Error %d: Could not read in array %s structure", status, 
		      arrayName);
   	return( status );
    }
   
    /* One should probably include a sanity check on the data types here */

    if (numAxes != numFoundAxes){
   	status = JEMX_SHARED_BAD_DIMENSIONS;
   	RILlogMessage(NULL, Error_2,
		      "Error %d: Array %s has wrong number of axes - "
		      "expected %d, found %d",
		      status, arrayName, numAxes, numFoundAxes);
   	return status ;    
    }

    totalDim = 1;
    for ( i=0 ; i<numAxes ; i++){
	if ( dimFoundAxes[i] != dimAxes[i]){
	    status =  JEMX_SHARED_BAD_DIMENSIONS;
	    RILlogMessage(NULL, Error_2,
			  "Error %d: Axis %d of %s has wrong length - "
			  "expected %ld, found %ld",
			  status, i, arrayName, dimAxes[i], dimFoundAxes[i] );
	    return(status);
	} 
	startRange[i] = 1;
	totalDim *= dimAxes[i];
    }

    /*
     * Allocate a buffer of suitable size for array as allocated in
     * _calling_ function.
     */

    status = DALarrayGetBuffSize(*arrayPtr, numAxes, arrayType, 
				 startRange, dimAxes, &bufferSize, status); 
    if ( status!= ISDC_OK){
	RILlogMessage(NULL, Error_2,
		      "Error %d: could not get array %s buffer size", 
		      status, arrayName);
	return status;
    }

    status = DALallocateDataBuffer(array,bufferSize,status);
    if (ISDC_OK!=status) {
	RILlogMessage(NULL,Error_2,
		      "Error %d allocating transfer buffer for %s!",
		      status,arrayName);
	return(status);
    }

    /*
     * Read in the data and map it to array.
     * Set the type on input to the data type used in the calling
     * function to ensure re-mapping, if necessary.
     */
    arrayTypeFound = arrayType;
    status = DALarrayGetSection(*arrayPtr,numAxes,startRange,dimAxes,
				&arrayTypeFound,
				&numPixels,(void*)*array,status);
    if (ISDC_OK!=status) {
	RILlogMessage(NULL,Error_2,
		      "Error %d reading data from %s!",
		      status,arrayName);
	return(status);
    }

    if (totalDim != numPixels) {
	status = JEMX_SHARED_BAD_DIMENSIONS;
	RILlogMessage(NULL,Error_2,
		      "Error %d: %s has %ld instead of %ld pixels!",
		      status,arrayName,numPixels,totalDim);
	return(status);
    } else if (J_CHATTY_VERY_VERBOSE<=chatter) {
	RILlogMessage(NULL,Log_0,
		      "Read %ld pixels from %s",numPixels,arrayName);
    }
    
    return(status);
}