/*--------------------------------------------------------------------------
         
                             N X A M O R

  Routines for writing NeXus files for the reflectometer AMOR at PSI.

  copyright: see copyright.h


  Mark Koennecke, September 1999
--------------------------------------------------------------------------*/
#include <stdlib.h>
#include <assert.h>
#include "fortify.h"
#include "sics.h"
#include "nxdict.h"
#include "nxutil.h"
#include "scan.h"
#include "scan.i"
#include "HistMem.h"
#include "counter.h"
#include "nxamor.h"

/* some defines for some names */
#define AMORDICT "amor.dic"
#define INSTNAME "AMOR at SINQ, PSI"
#define SOURCENAME "Spallation source SINQ"
#define SOURCETYPE "Continous flux spallation source"
#define CHOPPERNAME "Dornier Chopper System"
/* 
   this is the real detector size, the one in the dictionary will be
   updated from this!
*/
#define DETSIZE 128
/*------------------------------------------------------------------------*/
  static void WriteDiaphragm(NXhandle hfil, NXdict hdict, int i, 
                             SConnection *pCon)
  {
    char pThing[30];

    sprintf(pThing,"d%1.1ddist",i);
    SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,pThing,pThing);

    sprintf(pThing,"d%1.1dt",i);
    SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,pThing,pThing);
    sprintf(pThing,"d%1.1db",i);
    SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,pThing,pThing);
    sprintf(pThing,"d%1.1dl",i);
    SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,pThing,pThing);
    sprintf(pThing,"d%1.1dr",i);
    SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,pThing,pThing);
  }
/*----------------------------------------------------------------------*/
  int WriteAmorHeader(char *file, SConnection *pCon)
  {
       NXhandle hfil;
       NXdict hdict;
       int iRet;
       char pBueffel[512];
       CounterMode eMode;
       CommandList *pCom = NULL;
       float fVal;

       /* open files */
       iRet = NXopen(file,NXACC_CREATE,&hfil);
       if(iRet != NX_OK)
       {
	   sprintf(pBueffel,"ERROR: cannot open file %s for writing",file);
           SCWrite(pCon,pBueffel,eError);
           return 0;
       }
       iRet = NXDinitfromfile(AMORDICT,&hdict);
       if(iRet != NX_OK)
       {
	   sprintf(pBueffel,"ERROR: cannot open dictionary file %s");
           SCWrite(pCon,pBueffel,eError);
           return 0;
       }
 
       /* put some global information */
       SNXSPutGlobals(hfil,file,"AMOR",pCon);
       SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,"etitle","title");
       SNXFormatTime(pBueffel,512);
       NXDputalias(hfil,hdict,"estart",pBueffel);

       /* instrument vGroup */
       NXDputalias(hfil,hdict,"iname",INSTNAME);

       /* source */
       NXDputalias(hfil,hdict,"sname",SOURCENAME);
       NXDputalias(hfil,hdict,"stype",SOURCETYPE);

       /* chopper */
       NXDputalias(hfil,hdict,"cname",CHOPPERNAME);
       SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,"crot",
                       "chopperrotation");

       /* frame overlap mirror */
       SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,"fomname",
                       "fomname");
       SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,"fodist",
                       "fomdist");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"fomh","ftz");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"fomom","fom");

       /* first Diaphragm */
       WriteDiaphragm(hfil,hdict,1,pCon);

       /* polarizing, monochromating mirror */
       SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,"polname",
                       "polname");
       SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,"poldist",
                       "poldist");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"polz","moz");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"polom","mom");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"poly","mty");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"polzom","mtz");

       /* second Diaphragm */
       WriteDiaphragm(hfil,hdict,2,pCon);

       /* third Diaphragm */
       WriteDiaphragm(hfil,hdict,3,pCon);

       /* sample table */
       SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,"saname",
                       "sample");
       SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,"stdist",
                       "sampledist");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"somheight","stz");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"schi","sch");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"somega","som");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"stheight","soz");

       /* fourth Diaphragm */
       WriteDiaphragm(hfil,hdict,4,pCon);
      
       /* analyzer */
       SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,"anname",
                       "ananame");
       SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,"andist",
                       "anadist");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"anoz","atz");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"anom","aom");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"antz","aoz");

       /* fifth Diaphragm!!!!!!!!! */
       WriteDiaphragm(hfil,hdict,5,pCon);
       
       /* counting data */
       pCom = FindCommand(pServ->pSics,"counter");
       if(pCom)
       {
         if(pCom->pData)
	 {
            eMode = GetCounterMode((pCounter)pCom->pData);
            if(eMode == eTimer)
            {
              strcpy(pBueffel,"timer");
            }           
            else
            {
              strcpy(pBueffel,"monitor");
            }
            NXDputalias(hfil,hdict,"cnmode",pBueffel);
            fVal = GetCounterPreset((pCounter)pCom->pData);
            NXDputalias(hfil,hdict,"cnpreset",&fVal);
	 }       
       }
       else
       {
           SCWrite(pCon,"WARNING: failed to find counter!",eWarning);
       }
       NXclose(&hfil);
       NXDclose(hdict,NULL);

       return 1;      
  }
/*------------------------------------------------------------------------*/
  int WriteAmorScan(char *file, SConnection *pCon, pScanData pScan)
  {
       NXhandle hfil;
       NXdict hdict;
       int iRet, i;
       char pBueffel[512], pDefinition[1024];
       CommandList *pCom = NULL;
       float fVal;
       float *fAxis = NULL;
       long *lData  = NULL;
       int  *iData  = NULL;

       /* open files */
       iRet = NXopen(file,NXACC_RDWR,&hfil);
       if(iRet != NX_OK)
       {
	   sprintf(pBueffel,"ERROR: cannot open file %s for writing");
           SCWrite(pCon,pBueffel,eError);
           return 0;
       }
       iRet = NXDinitfromfile(AMORDICT,&hdict);
       if(iRet != NX_OK)
       {
	   sprintf(pBueffel,"ERROR: cannot open dictionary file %s");
           SCWrite(pCon,pBueffel,eError);
           return 0;
       }

       /* write general detector data */
       SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,"sdetdist",
                       "detectordist");
       

       /* allocate memory for writing scan data */
       fAxis = (float *)malloc(pScan->iNP*sizeof(float));       
       lData = (long *)malloc(pScan->iNP*sizeof(long));
       iData = (int *)malloc(pScan->iNP*sizeof(int));
       if( (!fAxis) || (!lData) || (!iData) )
       {
          SCWrite(pCon,"ERROR: out of memory in WriteAmorScan",eError);
          return 0;
       }       
       memset(fAxis,0,pScan->iNP*sizeof(float));
       memset(lData,0,pScan->iNP*sizeof(long));
       memset(iData,0,pScan->iNP*sizeof(int));

       /* write scan variables */
       for(i = 0; i < pScan->iScanVar; i++)
       {
	 /* build definition string */
          NXDget(hdict,"scanroot",pBueffel, 512);
          strcpy(pDefinition,pBueffel);
          strcat(pDefinition,"  ");
          GetScanVarName(pScan,i,pBueffel,512);
          strcat(pDefinition,pBueffel);
          sprintf(pBueffel," -rank 1 -dim {%d} ", pScan->iNP);
          strcat(pDefinition,pBueffel);
          if(i == 0)
          {
            strcat(pDefinition," -attr {axis,1}");
          }
          /* get data and write */
          GetScanVar(pScan,i,fAxis,pScan->iNP);
          NXDputdef(hfil,hdict,pDefinition,fAxis);
          if(i == 0)
          {
             NXDget(hdict,"sdana",pBueffel,512);
             NXDdeflink(hfil,hdict,pBueffel,pDefinition);
          }
       }

       /* 
          Write counted data: Here there is a convention which has to be
          valid in amorscan as well:  GetCounts gets the main detector.
          GetMonitor 0 the second detector, GetMonitor 1 the first detector
          other spin, GetMonitor 2, the second detector the other spin,
          getMonitor 3, the first monitor, getMonitor 4 the second monitor
        */
       sprintf(pBueffel,"%d",pScan->iNP);
       NXDupdate(hdict,"scanlength",pBueffel);
       GetScanCounts(pScan,lData,pScan->iNP);
       for(i = 0; i < pScan->iNP; i++)
       {
          iData[i] = (int)lData[i];
       }
       NXDputalias(hfil,hdict, "spinupup",iData);
       NXDaliaslink(hfil,hdict,"sdana","spinupup");
       GetScanMonitor(pScan,0,lData,pScan->iNP);
       for(i = 0; i < pScan->iNP; i++)
       {
          iData[i] = (int)lData[i];
       }
       NXDputalias(hfil,hdict, "spinuplo",iData);
       NXDaliaslink(hfil,hdict,"sdana","spinuplo");

       /* monitors */
       GetScanMonitor(pScan,3,lData,pScan->iNP);
       for(i = 0; i < pScan->iNP; i++)
       {
          iData[i] = (int)lData[i];
       }
       NXDputalias(hfil,hdict, "smonitor1",iData);
       GetScanMonitor(pScan,4,lData,pScan->iNP);
       for(i = 0; i < pScan->iNP; i++)
       {
          iData[i] = (int)lData[i];
       }
       NXDputalias(hfil,hdict, "smonitor2",iData);

       /* to be added: polarizing mode, possibly coz, cox, com etc. */
              
       /* a few motors which may or may not be useful */
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"sdetx","cox");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"sdetom","com");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"sdetheight","coz");
       
       /* close and go */
       NXclose(&hfil);
       NXDclose(hdict,NULL);
       free(fAxis);
       free(lData);
       free(iData); 

       return 1;      
  }
/*-----------------------------------------------------------------------*/
  int WriteAmorTOF(char *file, SConnection *pCon, pHistMem pHM)
  {
       NXhandle hfil;
       NXdict hdict;
       int iRet, i, iLength;
       char pBueffel[512];
       float fVal, *fAxis = NULL, *fTime2 = NULL;
       CommandList *pCom = NULL;
       const float *fTime;
       HistInt *lData = NULL, lVal;
 

       /* open files */
       iRet = NXopen(file,NXACC_RDWR,&hfil);
       if(iRet != NX_OK)
       {
	   sprintf(pBueffel,"ERROR: cannot open file %s for writing");
           SCWrite(pCon,pBueffel,eError);
           return 0;
       }
       iRet = NXDinitfromfile(AMORDICT,&hdict);
       if(iRet != NX_OK)
       {
	   sprintf(pBueffel,"ERROR: cannot open dictionary file %s");
           SCWrite(pCon,pBueffel,eError);
           return 0;
       }

       /* write general detector data */
       SNXSPutVariable(pServ->pSics,pCon,hfil, hdict,"detdist",
                       "detectordist");

       /* a few motors which may or may not be useful */
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"detx","cox");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"detom","com");
       SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"detheight","coz");
       
       /* write counter related stuff */
       pCom = FindCommand(pServ->pSics,"counter");
       if(pCom)
       {
         if(pCom->pData)
	 {
            fVal = GetCountTime((pCounter)pCom->pData,pCon);
            NXDputalias(hfil,hdict,"cntime",&fVal);

            /* the assignment of monitors has to be checked once
               the Schlumpf is done
	    */
            lVal = GetMonitor((pCounter)pCom->pData,2, pCon);
            NXDputalias(hfil,hdict,"cnmon1",&lVal);
            lVal = GetMonitor((pCounter)pCom->pData,3, pCon);
            NXDputalias(hfil,hdict,"cnmon2",&lVal);
	 }       
       }
       else
       {
           SCWrite(pCon,"WARNING: failed to find counter!",eWarning);
       }

       /* write two axis */
       fAxis = (float *)malloc(DETSIZE*sizeof(float));
       if(!fAxis)
       {
         SCWrite(pCon,"ERROR: out of memory in WriteAmorTOF",eError);
         return 0;
       }
       for(i = 0; i < DETSIZE; i++)
       {
          fAxis[i] = (float)i;
       }
       NXDputalias(hfil,hdict,"detxx",fAxis);
       NXDputalias(hfil,hdict,"dety",fAxis);
       NXDaliaslink(hfil,hdict,"dana","detxx");
       NXDaliaslink(hfil,hdict,"dana","dety");
       free(fAxis);

       /* update detector size */
       sprintf(pBueffel,"%d",DETSIZE);
       NXDupdate(hdict,"detsize",pBueffel);


       /* deal with time binning */
       fTime = GetHistTimeBin(pHM,&iLength);
       fTime2 = (float *)malloc(iLength*sizeof(float));
       if(fTime2)
       {
           for(i = 0; i < iLength; i++)
           {
               fTime2[i] = fTime[i]/10.;
           }
           sprintf(pBueffel,"%d",iLength);
           NXDupdate(hdict,"timebin",pBueffel);
           NXDputalias(hfil,hdict,"dettime",fTime2);
           NXDaliaslink(hfil,hdict,"dana","dettime");
           free(fTime2);
           fTime2 = NULL;
       }
       else
       {
          SCWrite(pCon,"ERROR: out of memory while writing time binning",
                  eError);
       }

       /* finally get histogram */
       iLength = GetHistLength(pHM);
       lData = (HistInt *)malloc(iLength*sizeof(HistInt));
       if(!lData)
       {
           SCWrite(pCon,
              "ERROR: out of memory, failed to write histogram",eError);
           return 0;
       }
       memset(lData,0,iLength*sizeof(HistInt));
       GetHistogram(pHM,pCon, 0,0,iLength,lData,iLength*sizeof(HistInt));
       NXDputalias(hfil,hdict,"spinup",lData);
       NXDaliaslink(hfil,hdict,"dana","spinup");

       /* to do: add polarizing code */

       free(lData);

       NXclose(&hfil);
       NXDclose(hdict,NULL);

       return 1;      
  }
/*-----------------------------------------------------------------------*/
  static pHistMem pMeme = NULL;

  int AmorStore(SConnection *pCon, SicsInterp *pSics, void *pData, 
                int argc, char *argv[])
  {
     char pBueffel[512], *pFile = NULL;
     int iRet;
     
     pFile = SNXMakeFileName(pSics,pCon);
     sprintf(pBueffel,"Writing file %s .....",pFile);
     SCWrite(pCon,pBueffel,eWarning);
     iRet =  WriteAmorHeader(pFile,pCon);
     if(iRet)
     {
        iRet = WriteAmorTOF(pFile,pCon,pMeme);
     }
     free(pFile);
     SCSendOK(pCon);
     return iRet;
  }      
/*---------------------------------------------------------------------*/
  int AmorStoreMake(SConnection *pCon, SicsInterp *pSics, void *pData, 
                int argc, char *argv[])
  {
     CommandList *pCom = NULL;
     char pBueffel[512];
     int iRet;

     if(argc < 2)
     {
        SCWrite(pCon,
         "ERROR: insufficient number of arguments to AmorStoreMake",
          eError);
        return 0;
     }

     /* we need one parameter which is the name of the histogram memory*/
     pCom = FindCommand(pServ->pSics,argv[1]);
     if(!pCom)
     {
       sprintf(pBueffel,"ERROR: Histogram memory %s NOT found", argv[1]);
       SCWrite(pCon,pBueffel,eError);
       return 0;
     }
     if(!pCom->pData)
     {
       sprintf(pBueffel,"ERROR: Histogram memory %s NOT found", argv[1]);
       SCWrite(pCon,pBueffel,eError);
       return 0;
     }
     pMeme = (pHistMem)pCom->pData;

     /* install command */
     iRet = AddCommand(pSics,"storeamor",
                        AmorStore,NULL,NULL);
     if(!iRet)
     {
         sprintf(pBueffel,"ERROR: duplicate command amorstore NOT created");
         SCWrite(pCon,pBueffel,eError);
         return 0;
     }
     return 1;
  }