Changeset 3243

Timestamp:

01/06/12 16:30:58 (5 months ago)

Author:

jos

Message:

Strip trailing whitespace

Files:

• trunk/lib/share/mccode-r.c (modified) (151 diffs)

trunk/lib/share/mccode-r.c

@@ -16 +16 @@
 * Runtime system for McStas and McXtrace.
 * Embedded within instrument in runtime mode.
-* Contains SECTIONS: 
+* Contains SECTIONS:
 *   MPI handling (sum, send, recv)
 *   format definitions
@@ -82 +82 @@
 /* Instrument input parameter type handling. */
 /*******************************************************************************
-* mcparm_double: extract double value from 's' into 'vptr' 
+* mcparm_double: extract double value from 's' into 'vptr'
 *******************************************************************************/
 static int
@@ -99 +99 @@
 
 /*******************************************************************************
-* mcparminfo_double: display parameter type double 
+* mcparminfo_double: display parameter type double
 *******************************************************************************/
 static char *
@@ -108 +108 @@
 
 /*******************************************************************************
-* mcparmerror_double: display error message when failed extract double 
+* mcparmerror_double: display error message when failed extract double
 *******************************************************************************/
 static void
@@ -118 +118 @@
 
 /*******************************************************************************
-* mcparmprinter_double: convert double to string 
+* mcparmprinter_double: convert double to string
 *******************************************************************************/
 static void
@@ -128 +128 @@
 
 /*******************************************************************************
-* mcparm_int: extract int value from 's' into 'vptr' 
+* mcparm_int: extract int value from 's' into 'vptr'
 *******************************************************************************/
 static int
@@ -150 +150 @@
 
 /*******************************************************************************
-* mcparminfo_int: display parameter type int 
+* mcparminfo_int: display parameter type int
 *******************************************************************************/
 static char *
@@ -159 +159 @@
 
 /*******************************************************************************
-* mcparmerror_int: display error message when failed extract int 
+* mcparmerror_int: display error message when failed extract int
 *******************************************************************************/
 static void
@@ -169 +169 @@
 
 /*******************************************************************************
-* mcparmprinter_int: convert int to string 
+* mcparmprinter_int: convert int to string
 *******************************************************************************/
 static void
@@ -179 +179 @@
 
 /*******************************************************************************
-* mcparm_string: extract char* value from 's' into 'vptr' (copy) 
+* mcparm_string: extract char* value from 's' into 'vptr' (copy)
 *******************************************************************************/
 static int
@@ -196 +196 @@
 
 /*******************************************************************************
-* mcparminfo_string: display parameter type string 
+* mcparminfo_string: display parameter type string
 *******************************************************************************/
 static char *
@@ -205 +205 @@
 
 /*******************************************************************************
-* mcparmerror_string: display error message when failed extract string 
+* mcparmerror_string: display error message when failed extract string
 *******************************************************************************/
 static void
@@ -215 +215 @@
 
 /*******************************************************************************
-* mcparmprinter_string: convert string to string (including esc chars) 
+* mcparmprinter_string: convert string to string (including esc chars)
 *******************************************************************************/
 static void
@@ -266 +266 @@
 
 /*******************************************************************************
-* mcestimate_error: compute sigma from N,p,p2 in Gaussian large numbers approx 
+* mcestimate_error: compute sigma from N,p,p2 in Gaussian large numbers approx
 *******************************************************************************/
 double mcestimate_error(double N, double p1, double p2)
@@ -281 +281 @@
 
 double (*mcestimate_error_p)
-  (double V2, double psum, double p2sum)=mcestimate_error; 
+  (double V2, double psum, double p2sum)=mcestimate_error;
 
 /* SECTION: MPI handling ==================================================== */
@@ -296 +296 @@
 int mc_MPI_Sum(double *sbuf, long count)
 {
-  
+
   if (!sbuf || count <= 0) return(MPI_ERR_COUNT);
   else {
@@ -305 +305 @@
     int    i=0;
     while (offset < count) {
-      if (!length || offset+length > count-1) length=count-offset; 
+      if (!length || offset+length > count-1) length=count-offset;
       else length=MPI_REDUCE_BLOCKSIZE;
-      MPI_Allreduce((double*)(sbuf+offset), (double*)(rbuf+offset), 
+      MPI_Allreduce((double*)(sbuf+offset), (double*)(rbuf+offset),
               length, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
       offset += length;
     }
-    
+
     for (i=0; i<count; i++) sbuf[i] = rbuf[i];
   }
@@ -320 +320 @@
 * mc_MPI_Send: Send array to MPI node by blocks to avoid buffer limit
 *******************************************************************************/
-int mc_MPI_Send(void *sbuf, 
+int mc_MPI_Send(void *sbuf,
                   long count, MPI_Datatype dtype,
                   int dest)
@@ -328 +328 @@
   int  tag=1;
   int  length=MPI_REDUCE_BLOCKSIZE; /* defined in mcstas.h */
-  
+
   if (!sbuf || count <= 0) return(MPI_ERR_COUNT);
   MPI_Type_size(dtype, &dsize);
 
   while (offset < count) {
-    if (offset+length > count-1) length=count-offset; 
+    if (offset+length > count-1) length=count-offset;
     else length=MPI_REDUCE_BLOCKSIZE;
     MPI_Send((void*)(sbuf+offset*dsize), length, dtype, dest, tag++, MPI_COMM_WORLD);
@@ -346 +346 @@
 *             the buffer must have been allocated previously.
 *******************************************************************************/
-int mc_MPI_Recv(void *sbuf, 
+int mc_MPI_Recv(void *sbuf,
                   long count, MPI_Datatype dtype,
                   int source)
@@ -354 +354 @@
   int  tag=1;
   int  length=MPI_REDUCE_BLOCKSIZE; /* defined in mcstas.h */
-  
+
   if (!sbuf || count <= 0) return(MPI_ERR_COUNT);
   MPI_Type_size(dtype, &dsize);
 
   while (offset < count) {
-    if (offset+length > count-1) length=count-offset; 
+    if (offset+length > count-1) length=count-offset;
     else length=MPI_REDUCE_BLOCKSIZE;
-    MPI_Recv((void*)(sbuf+offset*dsize), length, dtype, source, tag++, 
+    MPI_Recv((void*)(sbuf+offset*dsize), length, dtype, source, tag++,
             MPI_COMM_WORLD, MPI_STATUS_IGNORE);
     offset += length;
@@ -385 +385 @@
 *******************************************************************************/
 
-/* {Name, Extension, Header, Footer, 
+/* {Name, Extension, Header, Footer,
     BeginSection, EndSection, AssignTag;
     BeginData, EndData;
@@ -1013 +1013 @@
   int   dirlen=0;
   char *mem   =NULL;
-  
+
   dirlen = mcdirname ? strlen(mcdirname) : 0;
   mem = malloc(dirlen + strlen(name) + CHAR_BUF_LENGTH);
@@ -1020 +1020 @@
   }
   strcpy(mem, "");
-  
+
   /* prepend directory name to path if name does not contain a path */
   if (dirlen > 0 && !strchr(name, MC_PATHSEP_C)) {
@@ -1026 +1026 @@
     strcat(mem, MC_PATHSEP_S);
   } /* dirlen */
-  
+
   strcat(mem, name);
   if (!strchr(name, '.') && ext && strlen(ext))
@@ -1052 +1052 @@
     fprintf(stderr, "Warning: could not open output file '%s' in mode '%s' (mcnew_file)\n", mem, mode);
   else {
-    if (!mcopenedfiles || 
+    if (!mcopenedfiles ||
         (mcopenedfiles && mcopenedfiles_size <= strlen(mcopenedfiles)+strlen(mem))) {
       mcopenedfiles_size+=CHAR_BUF_LENGTH;
@@ -1059 +1059 @@
       else
         mcopenedfiles = realloc(mcopenedfiles, mcopenedfiles_size);
-    } 
+    }
     strcat(mcopenedfiles, " ");
     strcat(mcopenedfiles, mem);
   }
   free(mem);
-  
+
   return file;
 } /* mcnew_file */
@@ -1123 +1123 @@
 
 /*******************************************************************************
-* pfprintf: just as fprintf with positional arguments %N$t, 
+* pfprintf: just as fprintf with positional arguments %N$t,
 *   but with (char *)fmt_args being the list of arg type 't'.
 *   Needed as the vfprintf is not correctly handled on some platforms.
@@ -1169 +1169 @@
       { /* found a dollar following a percent  and a digit after percent */
         char  this_arg_chr[10];
-        
+
 
         /* extract positional argument index %*$ in fmt */
@@ -1193 +1193 @@
         } else if (strchr(printf_formats,tmp[1])) {
           fmt_pos = arg_posB[this_arg]+1;  /* found %s */
-        } else { 
+        } else {
           return(-fprintf(stderr,"pfprintf: must use only positional arguments (%s).\n", arg_posB[this_arg]));
         }
@@ -1294 +1294 @@
   char date[CHAR_BUF_LENGTH]; /* date as a string */
   char valid_parent[VALID_NAME_LENGTH];     /* who generates that: the simulation or mcstas */
-  
+
   if (mcdisable_output_files) return(-1);
   if (!detector.file_handle && !strstr(detector.format.Name,"NeXus")) return(-1);
   if (strcmp(part,"header") && strstr(detector.format.Name, "no header")) return (-2);
   if (strcmp(part,"footer") && strstr(detector.format.Name, "no footer")) return (-3);
-  
+
   /* initiate date and format string ======================================== */
-  
+
   date_l = detector.date_l;   /* use current write time (from import) by default */
   strncpy(date, detector.date, CHAR_BUF_LENGTH);
@@ -1309 +1309 @@
   else {
     HeadFoot = detector.format.Header; /* SIM header has simulation start time */
-    if (detector.file_handle == mcsiminfo_file 
+    if (detector.file_handle == mcsiminfo_file
         && !strcmp(detector.filename, mcsiminfo_name)) {
       date_l = mcstartdate;
@@ -1318 +1318 @@
   }
 
-  mcvalid_name(valid_parent, 
+  mcvalid_name(valid_parent,
     strlen(detector.filename) && detector.file_handle!=mcsiminfo_file ?
       detector.filename : detector.simulation, VALID_NAME_LENGTH);
-    
+
   /* output header ========================================================== */
 
@@ -1329 +1329 @@
       detector.prefix,                          /* %1$s  PRE  */
       detector.instrument,                      /* %2$s  SRC  */
-      strlen(detector.filename) ? 
+      strlen(detector.filename) ?
         detector.filename: detector.simulation, /* %3$s  FIL  */
       detector.format.Name,                     /* %4$s  FMT  */
@@ -1337 +1337 @@
       detector.date_l) == NX_ERROR) {           /* %8$li DATL */
         fprintf(stderr, "Error: writing NeXus header file %s (mcinfo_header)\n",
-          strlen(detector.filename) ? 
+          strlen(detector.filename) ?
             detector.filename: detector.simulation);
         /* close information data set opened by mcnxfile_section */
       return(-1);
-    } 
+    }
     else return(1);
   }
@@ -1349 +1349 @@
     detector.prefix,                          /* %1$s  PRE  */
     detector.instrument,                      /* %2$s  SRC  */
-    strlen(detector.filename) ? 
+    strlen(detector.filename) ?
       detector.filename: detector.simulation, /* %3$s  FIL  */
     detector.format.Name,                     /* %4$s  FMT  */
@@ -1379 +1379 @@
 
   /* remove quote chars in values =========================================== */
-  if (strstr(detector.format.Name, "Scilab") 
-   || strstr(detector.format.Name, "Matlab") 
+  if (strstr(detector.format.Name, "Scilab")
+   || strstr(detector.format.Name, "Matlab")
    || strstr(detector.format.Name, "IDL"))
     for(i = 0; i < strlen(value); i++) {
@@ -1386 +1386 @@
       if (value[i] == '\n'  || value[i] == '\r') value[i] = ';';
     }
-    
+
   /* output tag ============================================================= */
 #ifdef USE_NEXUS
@@ -1434 +1434 @@
   else                                strcpy(valid_parent, "root");
 
-  if (!strcmp(part,"end") && strlen(detector.prefix) >= 2) 
+  if (!strcmp(part,"end") && strlen(detector.prefix) >= 2)
     detector.prefix[strlen(detector.prefix)-2]='\0'; /* un-indent prefix */
-    
+
   /* output section ========================================================= */
 
@@ -1445 +1445 @@
       fprintf(stderr, "Error: writing NeXus section %s/%s=NX%s (mcfile_section)\n", parent, section, type);
       return(detector);
-    } 
+    }
   }
   else
@@ -1457 +1457 @@
     valid_parent,   /* %6$s  VPA  */
     level);         /* %7$i  LVL */
-    
+
   /* handle prefix++ and write section start ID ============================= */
 
@@ -1498 +1498 @@
     if (strlen(Parameters) >= CHAR_BUF_LENGTH-VALID_NAME_LENGTH) break;
   }
-  
+
   /* output data ============================================================ */
   mcinfo_tag(detector, name, "Parameters",    Parameters);
@@ -1534 +1534 @@
       char nxname[CHAR_BUF_LENGTH];
       int length;
-      if (mcinputtable[i].par == NULL) 
+      if (mcinputtable[i].par == NULL)
         strncpy(Parameters, (mcinputtable[i].val ? mcinputtable[i].val : ""), CHAR_BUF_LENGTH);
-      else 
+      else
         (*mcinputtypes[mcinputtable[i].type].printer)(Parameters, mcinputtable[i].par);
       sprintf(nxname, "%s", Parameters);
@@ -1574 +1574 @@
   snprintf(Parameters, CHAR_BUF_LENGTH, "%ld", mcseed);
   mcinfo_tag(detector, instr, "Seed", Parameters);
-  
+
   /* output parameter string ================================================ */
   if (!strstr(detector.format.Name, "McStas")) {
-#ifdef USE_NEXUS    
+#ifdef USE_NEXUS
     /* close simulation/information */
     if (strstr(detector.format.Name, "NeXus"))
     if (NXclosedata(mcnxHandle) == NX_ERROR)
       fprintf(stderr, "Warning: NeXus: could not close data set simulation/information in %s\n", detector.filename);
-#endif      
+#endif
     detector = mcfile_section(detector, "begin", instr, "parameters", "parameters", 3);
   }
-  
+
   for(i = 0; i < mcnumipar; i++) {
     if (mcget_run_num() || (mcinputtable[i].val && strlen(mcinputtable[i].val))) {
-      if (mcinputtable[i].par == NULL) 
+      if (mcinputtable[i].par == NULL)
         strncpy(Parameters, (mcinputtable[i].val ? mcinputtable[i].val : ""), CHAR_BUF_LENGTH);
-      else 
+      else
         (*mcinputtypes[mcinputtable[i].type].printer)(Parameters, mcinputtable[i].par);
-      if (strstr(detector.format.Name, "McStas")) 
+      if (strstr(detector.format.Name, "McStas"))
         fprintf(detector.file_handle, "%sParam: %s=%s\n", detector.prefix, mcinputtable[i].name, Parameters);
       else
@@ -1605 +1605 @@
     /* in the parameter group, create one SDS per parameter */
     mcnxfile_parameters(mcnxHandle);
-    
-    /* this can not be included in nexus-lib as it requires mcinputtypes which 
+
+    /* this can not be included in nexus-lib as it requires mcinputtypes which
       is defined only in mccode-r.c (points to function that are defined here) */
-    
-    
+
+
     /* re-open the simulation/information dataset */
     if (NXopendata(mcnxHandle, "information") == NX_ERROR) {
@@ -1616 +1616 @@
   }
 #endif
-  if (!strstr(detector.format.Name, "McStas")) 
+  if (!strstr(detector.format.Name, "McStas"))
     detector = mcfile_section(detector, "end", instr, "parameters", "parameters", 3);
-    
+
   fflush(NULL);
 
@@ -1633 +1633 @@
 {
   char parent[CHAR_BUF_LENGTH];
-  
+
   if (!detector.m || mcdisable_output_files) return;
 
@@ -1644 +1644 @@
     if (!detector.file_handle) return;
   }
-  
+
   /* parent must be a valid name */
   mcvalid_name(parent, detector.filename, VALID_NAME_LENGTH);
-  
+
   /* output data ============================================================ */
   mcinfo_tag(detector, parent, "type",       detector.type);
   mcinfo_tag(detector, parent, "Source",     mcinstrument_source);
-  mcinfo_tag(detector, parent, (strstr(detector.format.Name,"McStas") ? 
+  mcinfo_tag(detector, parent, (strstr(detector.format.Name,"McStas") ?
         "component" : "parent"),             detector.component);
   mcinfo_tag(detector, parent, "position",   detector.position);
 
   mcinfo_tag(detector, parent, "title",      detector.title);
-  mcinfo_tag(detector, parent, !mcget_run_num() || mcget_run_num() >= mcget_ncount() ? 
+  mcinfo_tag(detector, parent, !mcget_run_num() || mcget_run_num() >= mcget_ncount() ?
       "Ncount" : "ratio",      detector.ncount);
-    
+
   if (strlen(detector.filename)) {
     mcinfo_tag(detector, parent, "filename", detector.filename);
@@ -1665 +1665 @@
 
   mcinfo_tag(detector, parent, "statistics", detector.statistics);
-  mcinfo_tag(detector, parent, strstr(detector.format.Name, "NeXus") ? 
+  mcinfo_tag(detector, parent, strstr(detector.format.Name, "NeXus") ?
        "Signal" : "signal",                  detector.signal);
   mcinfo_tag(detector, parent, "values",     detector.values);
@@ -1671 +1671 @@
   if (detector.rank >= 1 || detector.rank == -1)
   {
-    mcinfo_tag(detector, parent, (strstr(detector.format.Name," scan ") ? 
+    mcinfo_tag(detector, parent, (strstr(detector.format.Name," scan ") ?
           "xvars" : "xvar"),                 detector.xvar);
-    mcinfo_tag(detector, parent, (strstr(detector.format.Name," scan ") ? 
+    mcinfo_tag(detector, parent, (strstr(detector.format.Name," scan ") ?
           "yvars" : "yvar"),                 detector.yvar);
     mcinfo_tag(detector, parent, "xlabel",   detector.xlabel);
@@ -1683 +1683 @@
   }
 
-  mcinfo_tag(detector, parent, abs(detector.rank)==1 && strstr(detector.format.Name, "McStas") ? 
+  mcinfo_tag(detector, parent, abs(detector.rank)==1 && strstr(detector.format.Name, "McStas") ?
                     "xlimits" : "xylimits", detector.limits);
   mcinfo_tag(detector, parent, "variables", detector.rank == -1 ?
                                             detector.zvar : detector.variables);
-      
+
    if (mcDetectorCustomHeader && strlen(mcDetectorCustomHeader)) {
      mcinfo_tag(detector, parent, "custom",  mcDetectorCustomHeader);
-   } 
+   }
 
    fflush(NULL);
@@ -1718 +1718 @@
   char   istransposed=0;
   char   c[CHAR_BUF_LENGTH]; /* temp var for signal label */
-  
+
   MCDETECTOR detector;
 
   /* build MCDETECTOR structure ============================================= */
   /* make sure we do not have NULL for char fields */
-  
+
   /* these also apply to simfile */
   strncpy (detector.filename,  filename ? filename : "",    CHAR_BUF_LENGTH);
@@ -1732 +1732 @@
     strcat(detector.filename, format.Extension);
   }
-  strncpy (detector.component, component ? component : "McStas component", CHAR_BUF_LENGTH); 
+  strncpy (detector.component, component ? component : "McStas component", CHAR_BUF_LENGTH);
   snprintf(detector.simulation, CHAR_BUF_LENGTH, "%s%s%s",
       mcdirname && strlen(mcdirname) ? mcdirname : ".", MC_PATHSEP_S, mcsiminfo_name);
   detector.format=format;
-  
+
   /* set prefix: # for McStas data files, VRML and Python */
-  strcpy(detector.prefix, 
-      (strstr(format.Name, "McStas") && (strlen(detector.filename)) ? 
+  strcpy(detector.prefix,
+      (strstr(format.Name, "McStas") && (strlen(detector.filename)) ?
       "# " : ""));
-  
+
   snprintf(detector.instrument, CHAR_BUF_LENGTH, "%s (%s)", mcinstrument_name, mcinstrument_source);
   snprintf(detector.user, CHAR_BUF_LENGTH,      "%s on %s",
@@ -1751 +1751 @@
   if (strlen(detector.date))   detector.date[strlen(detector.date)-1] = '\0'; /* remove last \n in date */
   detector.date_l = date_l;
-  
+
   if (!mcget_run_num() || mcget_run_num() >= mcget_ncount())
     snprintf(detector.ncount, CHAR_BUF_LENGTH, "%g", (double)mcget_ncount());
-  else 
+  else
     snprintf(detector.ncount, CHAR_BUF_LENGTH, "%g/%g", (double)mcget_run_num(), (double)mcget_ncount());
-    
+
   detector.p0         = p0; detector.p0_orig=p0;
   detector.p1         = p1; detector.p1_orig=p1;
   detector.p2         = p2; detector.p2_orig=p2;
   detector.file_handle= filename ? NULL : mcsiminfo_file;
-  
+
   /* handle transposition */
   if (!strstr(format.Name, "NeXus")) {
@@ -1770 +1770 @@
       long i=m; m=abs(n); n=abs(i); p=abs(p);
     }
-  } 
+  }
   m=abs(m); n=abs(n); p=abs(p); /* make sure dimensions are positive */
   detector.istransposed = istransposed;
-  
+
   /* determine detector rank (dimensionality) */
   if (!m || !n || !p || !p1) detector.rank = 4; /* invalid: exit with m=0 filename="" */
@@ -1781 +1781 @@
   else if (p == 1)           detector.rank = 2; /* 2D */
   else                       detector.rank = 3; /* 3D */
-  
+
   /* from rank, set type */
   switch (detector.rank) {
@@ -1791 +1791 @@
     default: m=0; strcpy(detector.type, ""); strcpy(detector.filename, "");/* invalid */
   }
-  
+
   detector.m    = m;
   detector.n    = n;
@@ -1807 +1807 @@
   detector.centerY    = 0;
   detector.halfwidthY = 0;
-  
+
   /* these only apply to detector files ===================================== */
 
@@ -1831 +1831 @@
   else
     snprintf(detector.variables, CHAR_BUF_LENGTH, "%s %s_err N", c, c);
-  
+
   /* limits */
   detector.xmin = x1;
@@ -1845 +1845 @@
   else
     snprintf(detector.limits, CHAR_BUF_LENGTH, "%g %g %g %g %g %g", x1, x2, y1, y2, z1, z2);
-  
-  if (!m || !n || !p) { 
+
+  if (!m || !n || !p) {
     return(detector);
   }
-  
+
   /* if MPI and nodes_nb > 1: reduce data sets when using MPI =============== */
   /* not for scan steps/multiarray (only processed by root */
@@ -1858 +1858 @@
     if (p1) mc_MPI_Sum(p1, abs(m*n*p));
     if (p2) mc_MPI_Sum(p2, abs(m*n*p));
-    
+
     if (!p0) {  /* additive signal must be then divided by the number of nodes */
       int i;
@@ -1876 +1876 @@
   double Nsum=0;
   double P2sum=0;
-  
+
   double sum_xz  = 0;
   double sum_yz  = 0;
@@ -1888 +1888 @@
   char   israw = (strstr(detector.format.Name," raw") != NULL);
   double *this_p1=NULL; /* new 1D McStas array [x I E N]. Freed after writing data */
-  
+
   /* if McStas/PGPLOT and rank==1 we create a new m*4 data block=[x I E N] */
   if (detector.rank == 1 && strstr(detector.format.Name,"McStas")) {
@@ -1895 +1895 @@
       exit(-fprintf(stderr, "Error: Out of memory creating %li 1D McStas data set for file '%s' (mcdetector_import)\n", detector.m*detector.n*detector.p*4*sizeof(double*), detector.filename));
   }
-  
+
   max_z = min_z = p1[0];
-  
+
   for(j = 0; j < n*p; j++)
   {
@@ -1912 +1912 @@
       E = p2 ? p2[index] : 0;
       if (p2 && !israw) p2[index] = (*mcestimate_error_p)(p0[i],p1[i],p2[i]); /* set sigma */
-      
+
       /* compute stats integrals */
       sum_xz += x*z;
@@ -1926 +1926 @@
       Nsum += N;
       P2sum += E;
-      
+
       if (isnan(z) || isnan(E) || isnan(N)) hasnan=1;
       if (isinf(z) || isinf(E) || isinf(N)) hasinf=1;
-      
+
       if (detector.rank == 1 && this_p1 && strstr(detector.format.Name,"McStas")) {
         /* fill-in 1D McStas array [x I E N] */
-        this_p1[index*4]   = x; 
+        this_p1[index*4]   = x;
         this_p1[index*4+1] = z;
         this_p1[index*4+2] = p2 ? p2[index] : 0;
@@ -1939 +1939 @@
     }
   } /* for j */
-  
+
   /* compute 1st and 2nd moments */
   if (sum_z && n*m*p)
@@ -1960 +1960 @@
   detector.centerY   = fmon_y;
   detector.halfwidthY= smon_y;
-  
+
   /* if McStas/PGPLOT and rank==1 replace p1 with new m*4 1D McStas and clear others */
   if (detector.rank == 1 && this_p1 && strstr(detector.format.Name,"McStas")) {
     detector.p1 = this_p1;
-    detector.n=detector.m; detector.m  = 4; 
+    detector.n=detector.m; detector.m  = 4;
     detector.p0 = NULL;
     detector.p2 = NULL;
     detector.istransposed = 1;
   }
-  
+
   if (n*m*p > 1)
     sprintf(detector.signal, "Min=%g; Max=%g; Mean=%g;", detector.min, detector.max, detector.mean);
-  else 
+  else
     strcpy(detector.signal, "");
   sprintf(detector.values, "%g %g %g", detector.intensity, detector.error, detector.events);
-  
+
   switch (detector.rank) {
     case 0:  strcpy(detector.statistics, ""); break;
-    case 1:  snprintf(detector.statistics, CHAR_BUF_LENGTH, "X0=%g; dX=%g;", 
+    case 1:  snprintf(detector.statistics, CHAR_BUF_LENGTH, "X0=%g; dX=%g;",
       detector.centerX, detector.halfwidthX); break;
     case 2:
-    case 3:  snprintf(detector.statistics, CHAR_BUF_LENGTH, "X0=%g; dX=%g; Y0=%g; dY=%g;", 
-      detector.centerX, detector.halfwidthX, detector.centerY, detector.halfwidthY); 
+    case 3:  snprintf(detector.statistics, CHAR_BUF_LENGTH, "X0=%g; dX=%g; Y0=%g; dY=%g;",
+      detector.centerX, detector.halfwidthX, detector.centerY, detector.halfwidthY);
       break;
     default: strcpy(detector.statistics, "");
@@ -1993 +1993 @@
   }
 #endif
-  
+
   /* output "Detector:" line ================================================ */
-  /* when this is a detector written by a component (not the SAVE from instrument), 
+  /* when this is a detector written by a component (not the SAVE from instrument),
      not a multiarray nor event lists */
   if (detector.rank == -1 || strstr(format.Name," list ")) return(detector);
-  
+
   if (!strcmp(detector.component, mcinstrument_name)) {
     if (strlen(detector.filename))  /* we name it from its filename, or from its title */
@@ -2006 +2006 @@
   } else
     strncpy(c, detector.component, CHAR_BUF_LENGTH);  /* usual detectors written by components */
-    
+
   printf("Detector: %s_I=%g %s_ERR=%g %s_N=%g",
-         c, detector.intensity, 
-         c, detector.error, 
+         c, detector.intensity,
+         c, detector.error,
          c, detector.events);
   printf(" \"%s\"\n", strlen(detector.filename) ? detector.filename : detector.component);
-  
-  if (hasnan) 
+
+  if (hasnan)
     printf("WARNING: Nan detected in component %s\n", detector.component);
-  if (hasinf) 
+  if (hasinf)
     printf("WARNING: Inf detected in component %s\n", detector.component);
-    
+
   /* add warning in case of low statistics or large number of bins in text format mode */
-  if (detector.error > detector.intensity/4) 
+  if (detector.error > detector.intensity/4)
     printf("WARNING: file '%s': Low Statistics\n",    detector.filename);
   else if (strlen(detector.filename)) {
-    if (m*n*p > 1000 && Nsum < m*n*p && Nsum) 
+    if (m*n*p > 1000 && Nsum < m*n*p && Nsum)
        printf(
         "WARNING: file '%s': Low Statistics (%g events in %ldx%ldx%ld bins).\n",
@@ -2034 +2034 @@
         detector.filename, format.Name, m,n,p);
   }
-  
+
   if (mcDetectorCustomHeader && strlen(mcDetectorCustomHeader)) {
    if (strstr(detector.format.Name, "Octave") || strstr(detector.format.Name, "Matlab"))
@@ -2056 +2056 @@
 #ifdef USE_MPI
   /* only for Master */
-  if(mpi_node_rank != mpi_node_root)                      return(NULL); 
+  if(mpi_node_rank != mpi_node_root)                      return(NULL);
 #endif
 
   if (detector.m) {
     /* add detector entry in the mcDetectorArray */
-    if (!mcDetectorArray || 
+    if (!mcDetectorArray ||
         (mcDetectorArray && mcDetectorArray_size <= mcDetectorArray_index)) {
       mcDetectorArray_size+=CHAR_BUF_LENGTH;
@@ -2073 +2073 @@
 
   return(mcDetectorArray);
-    
+
 } /* mcdetector_register */
 
@@ -2083 +2083 @@
 MCDETECTOR mcdetector_import_sim(void) {
   Coords zero={0.0,0.0,0.0};
-  MCDETECTOR detector=mcdetector_import(mcformat, "mcstas", NULL, 
+  MCDETECTOR detector=mcdetector_import(mcformat, "mcstas", NULL,
     0,0,0,            /* mnp */
     NULL, NULL, NULL, /* labels */
@@ -2104 +2104 @@
 static int mcsiminfo_init(FILE *f)
 {
-  
+
 #ifdef USE_MPI
   /* only for Master */
-  if(mpi_node_rank != mpi_node_root)                      return(-1); 
+  if(mpi_node_rank != mpi_node_root)                      return(-1);
 #endif
   if (mcdisable_output_files)                             return(-2);
@@ -2114 +2114 @@
   /* clear list of opened files to start new save session */
   if (mcopenedfiles && strlen(mcopenedfiles) > 0) strcpy(mcopenedfiles, "");
-  
+
   /* open sim file ========================================================== */
-  
+
 #ifdef USE_NEXUS
   /* NeXus sim info is the NeXus root file. */
@@ -2135 +2135 @@
     else mcsiminfo_file = f;
   }
-  
+
   if(!mcsiminfo_file)
     return(-fprintf(stderr,
             "Warning: could not open simulation description file '%s' (mcsiminfo_init)\n",
             mcsiminfo_name));
-  
+
   /* initialize sim file information, sets detector.file_handle=mcsiminfo_file */
   MCDETECTOR mcsiminfo = mcdetector_import_sim();
-  
+
   /* flag true for McStas or NX data format */
-  int  ismcstas_nx= (strstr(mcformat.Name, "McStas") || strstr(mcformat.Name, "NeXus")); 
-  
+  int  ismcstas_nx= (strstr(mcformat.Name, "McStas") || strstr(mcformat.Name, "NeXus"));
+
   /* start to write meta data =============================================== */
 
@@ -2168 +2168 @@
   mcsiminfo = mcfile_section(mcsiminfo, "begin", mcsiminfo.simulation, mcinstrument_name, "instrument", 1);
   mcinfo_instrument(mcsiminfo, mcinstrument_name);
-  
+
 #ifdef USE_NEXUS
   if (strstr(mcformat.Name, "NeXus")) {
@@ -2184 +2184 @@
   mcsiminfo = mcfile_section(mcsiminfo, "begin", mcsiminfo.simulation, mcsiminfo_name, "simulation", 2);
   mcsiminfo = mcinfo_simulation(mcsiminfo, mcsiminfo_name);
-  
+
 #ifdef USE_NEXUS
   /* close information SDS opened with mcfile_section(siminfo,"simulation") */
@@ -2212 +2212 @@
 
   mcdetector_write_content(mcDetectorArray, mcDetectorArray_index);
-  
+
   /* initialize sim file information, sets detector.file_handle=mcsiminfo_file */
   MCDETECTOR mcsiminfo = mcdetector_import_sim();
-  
+
   /* close those sections which were opened in mcsiminfo_init =============== */
-  if (!ismcstas_nx) { 
+  if (!ismcstas_nx) {
     mcfile_section(mcsiminfo, "end", mcsiminfo.simulation, mcsiminfo_name, "simulation", 2);
     mcfile_section(mcsiminfo, "end", mcsiminfo.simulation, mcinstrument_name, "instrument", 1);
@@ -2234 +2234 @@
     mcfile_section(mcsiminfo, "end", "mcstas", mcinstrument_name, "entry", 1);
   }
-#endif  
-  
+#endif
+
   /* close sim file ========================================================= */
 #ifdef USE_NEXUS
@@ -2262 +2262 @@
   char    valid_zlabel[VALID_NAME_LENGTH];
   char    valid_parent[VALID_NAME_LENGTH];
-  
+
   if (strstr(part,"data"))
   { this_p1=detector.p1; Begin = detector.format.BeginData; End = detector.format.EndData; }
@@ -2269 +2269 @@
   if (strstr(part,"ncount") || strstr(part,"events"))
   { this_p1=detector.p0;Begin = detector.format.BeginNcount; End = detector.format.EndNcount; }
-  
+
   if (!this_p1 || mcdisable_output_files) return(-1);
   if (!detector.file_handle && !strstr(detector.format.Name,"NeXus")) return(-1);
   if (!detector.rank) return(-1);
 
-  
+
   mcvalid_name(valid_xlabel, detector.xlabel, VALID_NAME_LENGTH);
   mcvalid_name(valid_ylabel, detector.ylabel, VALID_NAME_LENGTH);
   mcvalid_name(valid_zlabel, detector.zlabel, VALID_NAME_LENGTH);
   mcvalid_name(valid_parent, detector.filename, VALID_NAME_LENGTH);
-  
+
   /* output Begin =========================================================== */
-  if (!strstr(detector.format.Name,"NeXus") 
+  if (!strstr(detector.format.Name,"NeXus")
    && (!strstr(detector.format.Name,"binary") || strstr(part,"empty array"))
    && !strstr(detector.format.Name,"no header"))
@@ -2307 +2307 @@
       detector.zmin,         /* %21$g  ZMIN */
       detector.zmax);        /* %22$g  ZMAX */
-  
+
   /* output array */
   if (strstr(part,"empty array")) {
     /* skip array output: set as empty */
-    
+
     /* special case of IDL: can not have empty vectors. Init to 'external' */
     if (strstr(detector.format.Name, "IDL")) fprintf(detector.file_handle, "'external'");
   } else {
-#ifdef USE_NEXUS  
+#ifdef USE_NEXUS
     /* array NeXus ========================================================== */
     if (strstr(detector.format.Name,"NeXus")) {
-      if(mcnxfile_data(mcnxHandle, detector, part, 
+      if(mcnxfile_data(mcnxHandle, detector, part,
         valid_parent, valid_xlabel, valid_ylabel, valid_zlabel) == NX_ERROR) {
         fprintf(stderr, "Error: writing NeXus data %s/%s (mcfile_data)\n", valid_parent, detector.filename);
@@ -2325 +2325 @@
       return(1);
     } /* end if NeXus */
-#endif    
+#endif
     /* array non binary (text) ============================================== */
-    if (!strstr(detector.format.Name, "binary") 
-     && !strstr(detector.format.Name, "float") && !strstr(detector.format.Name, "double")) 
+    if (!strstr(detector.format.Name, "binary")
+     && !strstr(detector.format.Name, "float") && !strstr(detector.format.Name, "double"))
     {
       char eol_char[3];
@@ -2334 +2334 @@
       int isPython = (strstr(detector.format.Name, "Python") != NULL);
       int i,j;
-      if (isIDL) strcpy(eol_char,"$\n"); 
-      else if (isPython) strcpy(eol_char,"\\\n"); 
+      if (isIDL) strcpy(eol_char,"$\n");
+      else if (isPython) strcpy(eol_char,"\\\n");
       else strcpy(eol_char,"\n");
 
@@ -2352 +2352 @@
       } /* end 2 loops if not Binary */
     } /* end if !Binary */
-      
+
     /* array binary double =================================================== */
-    if (strstr(detector.format.Name, "double")) 
+    if (strstr(detector.format.Name, "double"))
     {
       long count=0;
       count = fwrite(this_p1, sizeof(double), detector.m*detector.n*detector.p, detector.file_handle);
-      if (count != detector.m*detector.n*detector.p) 
+      if (count != detector.m*detector.n*detector.p)
         fprintf(stderr, "Error: writing double binary file '%s' (%li instead of %li, mcfile_data)\n", detector.filename,count, detector.m*detector.n*detector.p);
     } /* end if Binary double */
 
     /* array binary float =================================================== */
-    if (strstr(detector.format.Name, "binary") || strstr(detector.format.Name, "float")) 
+    if (strstr(detector.format.Name, "binary") || strstr(detector.format.Name, "float"))
     {
       float *s;
@@ -2370 +2370 @@
       {
         long    i, count=0;
-        for (i=0; i<detector.m*detector.n*detector.p; i++) { 
+        for (i=0; i<detector.m*detector.n*detector.p; i++) {
           s[i] = (float)this_p1[i]; }
         count = fwrite(s, sizeof(float), detector.m*detector.n*detector.p, detector.file_handle);
-        if (count != detector.m*detector.n*detector.p) 
+        if (count != detector.m*detector.n*detector.p)
           fprintf(stderr, "Error writing float binary file '%s' (%li instead of %li, mcfile_data)\n",
             detector.filename,count, detector.m*detector.n*detector.p);
         free(s);
-      } else 
+      } else
       fprintf(stderr, "Error: Out of memory for writing %li float binary file '%s' (mcfile_data)\n",
         detector.m*detector.n*detector.p*sizeof(float), detector.filename);
     } /* end if Binary float */
   } /* end if not empty array */
-  
+
   /* output End ============================================================= */
   if (!strstr(detector.format.Name,"NeXus")
@@ -2421 +2421 @@
   /* MPI: only write sim by Master ========================================== */
 #ifdef USE_MPI
-  if(mpi_node_rank != mpi_node_root) return(detector);  
+  if(mpi_node_rank != mpi_node_root) return(detector);
 #endif
   /* skip invalid detectors */
   if (!detector.m || mcdisable_output_files) return(detector);
 
-  /* sim file has been initialized when starting simulation and when calling 
+  /* sim file has been initialized when starting simulation and when calling
    * mcsave ; this defines mcsiminfo_file as the SIM file handle
-   * and calls: 
+   * and calls:
    *    mcinfo_header
    *    mcfile_section begin instrument
@@ -2441 +2441 @@
    * The sim file (and mcnxHandle) is closed when ending mcsave
    */
-   
+
   MCDETECTOR simfile = mcdetector_import_sim(); /* store reference structure to SIM file */
-  
+
   /* add component and data section to SIM file */
   if (!strstr(detector.format.Name,"NeXus"))
     simfile = mcfile_section(simfile, "begin", detector.simulation, detector.component, "component", 3);
   simfile = mcfile_section(simfile, "begin", detector.component, detector.filename, "data", 4);
-  
+
   /* handle indentation for simfile */
   char prefix[CHAR_BUF_LENGTH];
   strncpy(prefix, detector.prefix, CHAR_BUF_LENGTH);
   strncpy(detector.prefix, simfile.prefix, CHAR_BUF_LENGTH);
-  
+
   /* WRITE detector information to sim file ================================= */
   mcinfo_data(detector, NULL);
@@ -2462 +2462 @@
       fprintf(stderr, "Warning: NeXus: could not close data set %s/information\n",
         detector.filename);
-#endif    
+#endif
   /* WRITE data link to SIM file */
   if (!strstr(detector.format.Name,"McStas") && !mcsingle_file) {
@@ -2472 +2472 @@
     detector.file_handle = file;
   }
-  
+
   /* close component and data sections in SIM file */
   simfile = mcfile_section(simfile, "end", detector.component, detector.filename, "data", 4);
   if (!strstr(detector.format.Name,"NeXus"))
     simfile = mcfile_section(simfile, "end", detector.simulation, detector.component, "component", 3);
-    
+
   strncpy(detector.prefix, prefix, CHAR_BUF_LENGTH);
 
-  return(detector); 
+  return(detector);
 } /* mcdetector_write_sim */
 
@@ -2486 +2486 @@
 * mcdetector_write_data: write information to data file and catenate lists
 *                        this is where we open/close data files
-*                        also free detector.p1=this_p1 field which may hold 
+*                        also free detector.p1=this_p1 field which may hold
 *                        1D McStas [x I Ierr N] array which is set in mcdetector_import
 *******************************************************************************/
@@ -2492 +2492 @@
 {
   /* skip if 0D or no filename or no data (only stored in sim file) */
-  if (!detector.rank || !strlen(detector.filename) 
+  if (!detector.rank || !strlen(detector.filename)
    || !detector.m) return(detector);
 
@@ -2508 +2508 @@
   }
 #endif
-  
+
   /* OPEN data file (possibly appending if already opened) ================== */
   if (mcformat_data.Name && strlen(mcformat_data.Name) && !mcsingle_file)
     detector.format = mcformat_data;
-  
+
   if (!strstr(detector.format.Name, "NeXus")) {
     /* explicitely open data file if not NeXus format */
@@ -2520 +2520 @@
     strcpy(mode,
            (strstr(detector.format.Name, "no header")
-            || strstr(detector.format.Name, "append") || strstr(detector.format.Name, "catenate") 
+            || strstr(detector.format.Name, "append") || strstr(detector.format.Name, "catenate")
             || strstr(mcopenedfiles, detector.filename) ?
            "a" : "w"));
     if (strstr(detector.format.Name, "binary")) strcat(mode, "b");
-    detector.file_handle = mcnew_file(!mcsingle_file ? 
-      detector.filename : mcsiminfo_name, 
+    detector.file_handle = mcnew_file(!mcsingle_file ?
+      detector.filename : mcsiminfo_name,
       detector.format.Extension, mode);
   } else {
@@ -2532 +2532 @@
     mcfile_section(detector, "begin", detector.component, detector.filename, "data", 4);
   }
-  
+
   /* WRITE data header (except when in 'no header') */
   if (!strstr(detector.format.Name, "no header")) {
@@ -2550 +2550 @@
       fprintf(stderr, "Warning: NeXus: could not close data set %s/information (footer)\n",
         detector.filename);
-  /* group remains opened for data to be written */    
-#endif   
-  
+  /* group remains opened for data to be written */
+#endif
+
   /* case: list of events =================================================== */
   if (strstr(detector.format.Name," list ")) {
-  
+
 #ifdef USE_MPI
     if (mpi_node_rank != mpi_node_root) {
@@ -2564 +2564 @@
       if (mc_MPI_Send(mnp, 3, MPI_INT, mpi_node_root)!= MPI_SUCCESS)
         fprintf(stderr, "Warning: proc %i to master: MPI_Send mnp list error (mcdetector_write_data)", mpi_node_rank);
-      if (!detector.p1 
+      if (!detector.p1
        || mc_MPI_Send(detector.p1, abs(mnp[0]*mnp[1]*mnp[2]), MPI_DOUBLE, mpi_node_root) != MPI_SUCCESS)
         fprintf(stderr, "Warning: proc %i to master: MPI_Send p1 list error (mcdetector_write_data)", mpi_node_rank);
@@ -2573 +2573 @@
 
     /* master node or non-MPI list: store data block */
-    int     master_mnp[3]={detector.m,detector.n,detector.p}; 
-    
+    int     master_mnp[3]={detector.m,detector.n,detector.p};
+
 #ifdef USE_MPI
     int     node_i=0;
@@ -2591 +2591 @@
         detector.p1 = this_p1;
         detector.m  = mnp[0]; detector.n  = mnp[1]; detector.p  = mnp[2];
-      } else 
+      } else
 #endif
       { /* MASTER/single node use its own detector structure */
@@ -2597 +2597 @@
         detector.m  = master_mnp[0]; detector.n  = master_mnp[1]; detector.p  = master_mnp[2];
       }
-    
+
       /* WRITE list data (will be catenated in case of MPI as file is already opened) */
       mcfile_data(detector, "data");
-    
+
 #ifdef USE_MPI
       /* free temporary MPI block used for Recv from slaves */
-      if (this_p1 && node_i != mpi_node_root) 
+      if (this_p1 && node_i != mpi_node_root)
         free(this_p1);
       detector.p0 = detector.p0_orig;
@@ -2609 +2609 @@
       detector.p2 = detector.p2_orig;
       detector.m  = master_mnp[0]; detector.n  = master_mnp[1]; detector.p  = master_mnp[2];
-    
+
     } /* for node_i: end loop on nodes */
 #endif
@@ -2617 +2617 @@
   {
   /* case: normal detector ================================================== */
-  
+
     /* WRITE data */
     mcfile_data(detector, "data");
-    
+
     /* write errors (not for lists) */
     if (detector.p2) mcfile_data(detector, "errors");
-    
+
     /* write events (not for lists) */
     if (detector.p0) mcfile_data(detector, "events");
-    
+
     if (detector.rank == 1 && detector.p1 && strstr(detector.format.Name,"McStas")) {
       free(detector.p1);  /* 'this_p1' allocated in mcdetector_write_sim for 1D McStas data sets [x I E N] */
@@ -2635 +2635 @@
     }
   } /* end normal detector case */
-  
+
   /* WRITE data footer (except when 'no footer') */
   if (!strstr(detector.format.Name, "no footer") && !strstr(mcformat.Name, "NeXus")) {
@@ -2642 +2642 @@
       mcinfo_header(detector, "footer");
   }
-    
+
   /* close data file and free memory */
   if (mcDetectorCustomHeader && strlen(mcDetectorCustomHeader)) {
     free(mcDetectorCustomHeader); mcDetectorCustomHeader=NULL; }
-  
+
   if (!strstr(mcformat.Name, "NeXus") && detector.file_handle != mcsiminfo_file
-   && !mcdisable_output_files && detector.file_handle) 
+   && !mcdisable_output_files && detector.file_handle)
     fclose(detector.file_handle);
   else if (strstr(mcformat.Name, "NeXus")) {
@@ -2655 +2655 @@
   }
 
-  return(detector); 
+  return(detector);
 } /* mcdetector_write_data */
 
@@ -2666 +2666 @@
 #ifdef USE_MPI
   /* only for Master */
-  if(mpi_node_rank != mpi_node_root)                      return(-1); 
+  if(mpi_node_rank != mpi_node_root)                      return(-1);
 #endif
   if (mcdisable_output_files)                             return(-2);
@@ -2675 +2675 @@
   double *this_p1 = (double *)calloc(DetectorArray_index*2, sizeof(double));
   int i;
-  
+
   if (this_p1 && DetectorArray) {
     char   *labels=NULL;
@@ -2689 +2689 @@
         mcvalid_name(valid, DetectorArray[i].filename, CHAR_BUF_LENGTH);
         sprintf(mem, "%s_I %s_Err ", valid, valid);
-        if (!labels || 
+        if (!labels ||
           (labels && labels_size <= strlen(labels)+strlen(mem))) {
           labels_size+=CHAR_BUF_LENGTH;
@@ -2696 +2696 @@
           else
             labels = realloc(labels, labels_size);
-        } 
+        }
         strcat(labels, " ");
         strcat(labels, mem);
     } /* for */
-    
+
     struct mcformats_struct format=mcformat;
     strcat(format.Name, " scan step");
     Coords zero={0.0,0.0,0.0};
-    
+
     /* now create detector and write 'abstract' file */
     MCDETECTOR detector = mcdetector_import(format,
@@ -2713 +2713 @@
       0, index-1, 0, 0, 0, 0, "content",  /* use name from OpenOffice content.xml description file */
       NULL, this_p1, NULL, zero);
-      
+
     mcdetector_write_data(detector);
 
     free(labels); labels=NULL; labels_size=0;
-    
+
     /* free DETECTOR array */
     free(this_p1); this_p1=NULL;
@@ -2739 +2739 @@
     0, 0, 0, 0, 0, 0, "",
     &p0, &p1, &p2, posa); /* write Detector: line */
-    
+
   /* write detector to simulation file (incl custom header if any) */
-  detector = mcdetector_write_sim(detector); 
+  detector = mcdetector_write_sim(detector);
   mcdetector_register(detector);
   return(detector);
@@ -2750 +2750 @@
 *******************************************************************************/
 MCDETECTOR mcdetector_out_1D(char *t, char *xl, char *yl,
-        char *xvar, double x1, double x2, 
+        char *xvar, double x1, double x2,
         int n,
         double *p0, double *p1, double *p2, char *f,
@@ -2763 +2763 @@
     x1, x2, 0, 0, 0, 0, f,
     p0, p1, p2, posa); /* write Detector: line */
-    
+
   /* write detector to simulation and data file (incl custom header if any) */
   detector = mcdetector_write_sim(detector);
@@ -2775 +2775 @@
 *******************************************************************************/
 MCDETECTOR mcdetector_out_2D(char *t, char *xl, char *yl,
-                  double x1, double x2, double y1, double y2, 
-                  int m, int n, 
+                  double x1, double x2, double y1, double y2,
+                  int m, int n,
                   double *p0, double *p1, double *p2, char *f,
                   char *c, Coords posa)
@@ -2816 +2816 @@
 MCDETECTOR mcdetector_out_3D(char *t, char *xl, char *yl, char *zl,
       char *xvar, char *yvar, char *zvar,
-      double x1, double x2, double y1, double y2, double z1, double z2, 
-      int m, int n, int p, 
-      double *p0, double *p1, double *p2, char *f, 
+      double x1, double x2, double y1, double y2, double z1, double z2,
+      int m, int n, int p,
+      double *p0, double *p1, double *p2, char *f,
       char *c, Coords posa)
 {
@@ -2829 +2829 @@
     x1, x2, y1, y2, z1, z2, f,
     p0, p1, p2, posa); /* write Detector: line */
-    
+
   /* write detector to simulation and data file (incl custom header if any) */
   detector = mcdetector_write_sim(detector);
@@ -2838 +2838 @@
 
 /*******************************************************************************
-* mcuse_format_header: Replaces aliases names in format fields (header part) 
+* mcuse_format_header: Replaces aliases names in format fields (header part)
 *******************************************************************************/
 char *mcuse_format_header(char *format_const)
@@ -2861 +2861 @@
 
 /*******************************************************************************
-* mcuse_format_tag: Replaces aliases names in format fields (tag part) 
+* mcuse_format_tag: Replaces aliases names in format fields (tag part)
 *******************************************************************************/
 char *mcuse_format_tag(char *format_const)
@@ -2882 +2882 @@
 
 /*******************************************************************************
-* mcuse_format_section: Replaces aliases names in format fields (section part) 
+* mcuse_format_section: Replaces aliases names in format fields (section part)
 *******************************************************************************/
 char *mcuse_format_section(char *format_const)
@@ -2904 +2904 @@
 
 /*******************************************************************************
-* mcuse_format_data: Replaces aliases names in format fields (data part) 
+* mcuse_format_data: Replaces aliases names in format fields (data part)
 *******************************************************************************/
 char *mcuse_format_data(char *format_const)
@@ -3013 +3013 @@
 
 /*******************************************************************************
-* mcclear_format: free format structure 
+* mcclear_format: free format structure
 *******************************************************************************/
 void mcclear_format(struct mcformats_struct usedformat)
@@ -3034 +3034 @@
 
 /*******************************************************************************
-* mcuse_file: will save data/sim files 
+* mcuse_file: will save data/sim files
 *******************************************************************************/
 static void mcuse_file(char *file)
@@ -3049 +3049 @@
 
 /*******************************************************************************
-* mcset_ncount: set total number of rays to generate 
+* mcset_ncount: set total number of rays to generate
 *******************************************************************************/
 void mcset_ncount(unsigned long long int count)
@@ -3072 +3072 @@
 mcsetn_arg(char *arg)
 {
-  mcset_ncount((long long int) strtod(arg, NULL)); 
+  mcset_ncount((long long int) strtod(arg, NULL));
 }
 
@@ -3386 +3386 @@
     double cz = cos(phz);
     double sz = sin(phz);
-    
+
     t[0][0] = cy*cz;
     t[0][1] = sx*sy*cz + cx*sz;
@@ -3396 +3396 @@
     t[2][1] = -sx*cy;
     t[2][2] = cx*cy;
-  } 
+  }
 }
 
@@ -3402 +3402 @@
 * rot_test_identity: Test if rotation is identity
 *******************************************************************************/
-int 
+int
 rot_test_identity(Rotation t)
 {
@@ -3465 +3465 @@
 {
   Coords b;
-  if (rot_test_identity(t)) { 
+  if (rot_test_identity(t)) {
     return a;
   } else {
@@ -3526 +3526 @@
     *z = b.z;
   }
-  
+
   if (vx != NULL && vy != NULL && vz != NULL) mccoordschange_polarisation(t, vx, vy, vz);
-  
+
   if (sx != NULL && sy != NULL && sz != NULL) mccoordschange_polarisation(t, sx, sy, sz);
 
@@ -3616 +3616 @@
 {
   int ret=0;
-  
+
   if (!t1) return 0;
   *t1 = 0;
@@ -3657 +3657 @@
  * randvec_target_circle: Choose random direction towards target at (x,y,z)
  * with given radius.
- * If radius is zero, choose random direction in full 4PI, no target. 
+ * If radius is zero, choose random direction in full 4PI, no target.
  ******************************************************************************/
 void
@@ -3722 +3722 @@
  * (xi,yi,zi) with given ANGULAR dimension height x width. height=phi_x,
  * width=phi_y (radians)
- * If height or width is zero, choose random direction in full 4PI, no target. 
+ * If height or width is zero, choose random direction in full 4PI, no target.
  *******************************************************************************/
 void
@@ -3794 +3794 @@
  * (See remarks posted to mcstas-users by George Apostolopoulus <gapost@ipta.demokritos.gr>)
  *
- * If height or width is zero, choose random direction in full 4PI, no target. 
- * 
+ * If height or width is zero, choose random direction in full 4PI, no target.
+ *
  * Traditionally, this routine had the name randvec_target_rect - this is now a
  * a define (see mcstas-r.h) pointing here. If you use the old rouine, you are NOT
- * taking the local emmission coordinate into account. 
+ * taking the local emmission coordinate into account.
 *******************************************************************************/
 
 void
 randvec_target_rect_real(double *xo, double *yo, double *zo, double *solid_angle,
-               double xi, double yi, double zi, 
-               double width, double height, Rotation A, 
+               double xi, double yi, double zi,
+               double width, double height, Rotation A,
                double lx, double ly, double lz, int order)
 {
@@ -3873 +3873 @@
       lz = *zo - lz;
       dist_p = sqrt(lx*lx + ly*ly + lz*lz);
-      
+
       /* Adjust the 'solid angle' */
       /* 1/r^2 to the chosen point times cos(\theta) between the normal */
       /* vector of the target rectangle and direction vector of the chosen point. */
       cos_theta = (xi * lx + yi * ly + zi * lz) / (dist * dist_p);
-      *solid_angle = width * height / (dist_p * dist_p); 
+      *solid_angle = width * height / (dist_p * dist_p);
       int counter;
       for (counter = 0; counter < order; counter++) {
@@ -4198 +4198 @@
 }
 
-/** 
+/**
  * Return a random number between 1 and -1
  */
@@ -4229 +4229 @@
 
 /*******************************************************************************
-* mchelp: displays instrument executable help with possible options 
+* mchelp: displays instrument executable help with possible options
 *******************************************************************************/
 static void
@@ -4292 +4292 @@
 } /* mchelp */
 
+
 /* mcshowhelp: show help and exit with 0 */
 static void
@@ -4297 +4298 @@
 {
   mchelp(pgmname);
-#ifdef USE_MPI
-#undef exit
-#endif
   exit(0);
-#ifdef USE_MPI
-#define exit(code) MPI_Abort(MPI_COMM_WORLD, code)
-#endif
 }
 
@@ -4334 +4329 @@
 /*******************************************************************************
  * mcuse_dir: set data/sim storage directory and create it,
- * or exit with error if exists 
+ * or exit with error if exists
  ******************************************************************************/
 static void
@@ -4345 +4340 @@
   exit(1);
 #else  /* !MC_PORTABLE */
-#ifdef USE_MPI  
+#ifdef USE_MPI
   if(mpi_node_rank == mpi_node_root)
   {
@@ -4352 +4347 @@
 #ifndef DANSE
       fprintf(stderr, "Error: unable to create directory '%s' (mcuse_dir)\n", dir);
-      fprintf(stderr, "(Maybe the directory already exists?)\n");       
+      fprintf(stderr, "(Maybe the directory already exists?)\n");
       exit(1);
 #endif
@@ -4364 +4359 @@
   else
     mcdirname = dir+strlen("file:/");
-    
+
   /* remove trailing PATHSEP (if any) */
-  while (strlen(mcdirname) && mcdirname[strlen(mcdirname) - 1] == MC_PATHSEP_C) 
+  while (strlen(mcdirname) && mcdirname[strlen(mcdirname) - 1] == MC_PATHSEP_C)
     mcdirname[strlen(mcdirname) - 1]='\0';
 #endif /* !MC_PORTABLE */
@@ -4372 +4367 @@
 
 /*******************************************************************************
-* mcinfo: display instrument simulation info to stdout and exit 
+* mcinfo: display instrument simulation info to stdout and exit
 *******************************************************************************/
 static void
@@ -4391 +4386 @@
 
 /*******************************************************************************
-* mcreadparams: request parameters from the prompt (or use default) 
+* mcreadparams: request parameters from the prompt (or use default)
 *******************************************************************************/
 void
@@ -4474 +4469 @@
 
 /*******************************************************************************
-* mcparseoptions: parse command line arguments (options, parameters) 
+* mcparseoptions: parse command line arguments (options, parameters)
 *******************************************************************************/
 void
@@ -4584 +4579 @@
     }
     else if(!strcmp("--no-output-files", argv[i]))
-      mcdisable_output_files = 1;   
+      mcdisable_output_files = 1;
     else if(argv[i][0] != '-' && (p = strchr(argv[i], '=')) != NULL)
     {
@@ -4643 +4638 @@
 
 #ifndef NOSIGNALS
-mcstatic char  mcsig_message[256]; 
-
-
-/*******************************************************************************
-* sighandler: signal handler that makes simulation stop, and save results 
+mcstatic char  mcsig_message[256];
+
+
+/*******************************************************************************
+* sighandler: signal handler that makes simulation stop, and save results
 *******************************************************************************/
 void sighandler(int sig)
@@ -4727 +4722 @@
   else
   {
-    printf("%.2f %% (%10.1f/%10.1f)\n", 100.0*mcget_run_num()/mcget_ncount(), 1.0*mcget_run_num(), 1.0*mcget_ncount()); 
+    printf("%.2f %% (%10.1f/%10.1f)\n", 100.0*mcget_run_num()/mcget_ncount(), 1.0*mcget_run_num(), 1.0*mcget_ncount());
   }
   t0 = (time_t)mcstartdate;
@@ -4771 +4766 @@
 
 /*******************************************************************************
-* mccode_main: McCode main() function. 
+* mccode_main: McCode main() function.
 *******************************************************************************/
 int mccode_main(int argc, char *argv[])