/* part_write_dx.c
 *
 *   Last change: Mon May  8 23:09:43 EDT 1995
 *
 *   Modified rml 9/12/95 - added cellfile and nodefile feature
 *       processors now numbered 0..NPROCS-1
 *   Modified rml 10/6/95 - added error detection for file i/o
 *       and optional compression
 */


/* #include "/dept/scorec/big/teresj/PMDB-3.2/src/include/libpmshops.h" */
#include "libpmshops.h"
#include "msg.h"


/*
 * declarations
 *
 */


extern int my_pmdb_write_dx(
       char    *file,
       pMeshPB  pmeshpb,
       char     *cellfile,
       int      celldim,
       char     *nodefile,
       int      nodedim,
       int      compress);

static int dx_owc_object(
       char    *filename,
       pMesh    mesh,
       char     *cellfile,
       int      celldim,
       char     *nodefile,
       int      nodedim);

static int dx_owc_group(
       char    *filename,
       pMesh    mesh,
       char     *cellfile,
       int      celldim,
       char     *nodefile,
       int      nodedim);

static int dx_write_object(
       FILE  *fp,
       pMesh  mesh,
       char *cellfile,
       int celldim,
       char *nodefile,
       int nodedim);

static int dx_write_group(
       FILE   *fp, 
       pMesh   mesh,
       char    *cellfile,
       char    *nodefile);

static void dx_number_verts(pMesh   mesh);

static void dx_clean_verts(pMesh   mesh);



/*
 * macro for checking return from fprintf
 * should only be used if routine doesn't need to
 * clean up before returning
 * calling routine should decare "int ret" and
 * do a "return(ret)" at the end
 *
 */

#define FPRINTF  if (ret==EOF) return(0); else ret=fprintf



/*
 * Main routine
 *
 * int my_pmdb_write_dx(char    *filename,
 *                      pMeshPB  pmeshpb,
 *                      char     *cellfile,
 *                      int      celldim,
 *                      char     *nodefile,
 *                      int      nodedim,
 *                      int      compress)
 *
 * Write out a dx file of the current mesh.  There is only one file
 * containing a component for each processor's part of the mesh.
 *
 * If cellfile is non-null, it specifies a file name template for cell
 * data.  The cellfile string must contain a %d which will be replaced
 * with the processor number.  You should create a separate cell data
 * file for each processor.  Each file should have one line for each
 * cell (in order of M_nextRegion() ) with celldim numbers on each
 * line.  E.g. cellfile name "cell.%d.dat" will make dx look for cell
 * data in cell.0.dat, cell.1.dat, etc.  Cellfile may be NULL in which
 * case there is no cell data attached to the dx object.
 *
 * Likewise for nodefile and nodedim. 
 *
 * If compress is nonzero, the dx file will be compressed after
 * it is written.
 *
 * Returns 0/nonzero for failure/success.
 *  It should catch ANY file i/o errors e.g. out of disk space
 *  Note: Failure to compress prints out a warning but does not cause
 *  the routine to return 0.
 *
 */


static char *funcname="pmdb_write_dx";


int my_pmdb_write_dx(
char    *filename,
pMeshPB  pmeshpb,
char     *cellfile,
int      celldim,
char     *nodefile,
int      nodedim,
int      compress)
{
  pMesh mesh;
  char dxname[FILENAME_MAX]; 
  int  i; 
  int ret;
  
  int status;
  char command[128];
  
  ret=1;
  mesh=pmdb_get_pmesh(pmeshpb);
  
  sprintf(dxname,"%s.dx",filename);
  dx_number_verts(mesh); 
  
  for(i=0; (i<NUMPROCS) && ret ; i++)
    {
      if (MYPID==i)
	ret=dx_owc_object(dxname,mesh,cellfile,celldim,nodefile,nodedim);

      ret=msg_int_bcast(ret,i);	/* synchronization */
    }
  
  if (!ret)
    return(0);
  
  if (MYPID==MASTER)
    {
      ret=dx_owc_group(dxname,mesh,cellfile,celldim,nodefile,nodedim);

      sprintf(command,"gzip -f %s",dxname);

      if (status=system(command))
	fprintf(stderr,"%s: warning, command %s returned status %d\n",
		funcname,command,status);
    }
  
  dx_clean_verts(mesh); 
  
  ret=msg_int_bcast(ret,MASTER);
  return(ret);
}



/*
 * dx_owc_object
 *
 * open, write, and close
 * (write a processor's object to the dx file)
 *
 */

static int dx_owc_object(
char    *filename,
pMesh    mesh,
char     *cellfile,
int      celldim,
char     *nodefile,
int      nodedim)
{
  FILE *fp; 
  int ret;

  if (MYPID==MASTER) 
    fp = fopen(filename,"w");
  else 
    fp = fopen(filename,"a");
  
  if (fp==NULL)
    {
      fprintf(stderr,"%s: could not open %s for write\n",funcname,filename);
      return(0);
    }
  
  /* write one proc's mesh */
  ret=dx_write_object(fp,mesh,cellfile,celldim,nodefile,nodedim);
  
  if (!ret)
    fprintf(stderr,"%s: error writing object %d to file %s\n",
	    funcname,MYPID,filename);
  
  if (fclose(fp)!=0)
    {
      fprintf(stderr,"%s: could not close %s\n",funcname,filename);
      ret=0;
    }

  return(ret);
}




/*
 * dx_owc_group
 *
 * open, write, and close group section of dx file
 * (write a processor's object to the dx file)
 *
 */

static int dx_owc_group(
char    *filename,
pMesh    mesh,
char     *cellfile,
int      celldim,
char     *nodefile,
int      nodedim)
{
  FILE *fp;
  int ret;

  fp = fopen(filename,"a");
  if (fp==NULL)
    {
      fprintf(stderr,"%s: cannot open file %s\n",funcname,filename);
      return(0);
    }
  
  /* write group dx object */
  ret=dx_write_group(fp,mesh,cellfile,nodefile); 

  if (!ret)
    fprintf(stderr,"%s: error writing group section of file %s\n",
	    funcname,filename);

  if (fclose(fp)!=0)
    {
      fprintf(stderr,"%s: error closing file %s\n",funcname,filename);
      ret=0;
    }

  return(ret);
}





static int dx_write_object(
FILE  *fp,
pMesh  mesh,
char *cellfile,
int celldim,
char *nodefile,
int nodedim)
{
   long    i,nvert,nreg; 
   void    *temp; 
   pPList  list;
   pVertex vertex; 
   pRegion region; 
   pPoint  point;
   int     vnum; 
   int     j; 
   int     ret=0;         /* SEE FPRINTF MACRO COMMENT */
   
   FPRINTF(fp,"#\n"); 
   FPRINTF(fp,"###########  Processor %d  #########\n",MYPID); 

   nvert = M_nVertex(mesh);
   nreg = M_nRegion(mesh);

   /*
    * Positions  
    */

   FPRINTF(fp,"#\n"); 
   FPRINTF(fp,"object \"pos.%d\"\n",MYPID); 
   FPRINTF(fp,"class array type float rank 1 shape 3 items %ld\n",nvert); 
   FPRINTF(fp,"data follows\n"); 

   temp=NULL;   
   while (vertex = M_nextVertex(mesh,&temp))
     {
       point = V_point(vertex);
       FPRINTF(fp," %E %E %E\n",P_x(point),P_y(point),P_z(point));
     }
   
   /*
    * Connections (elements)
    */

   FPRINTF(fp,"#\n"); 
   FPRINTF(fp,"object \"con.%d\"\n",MYPID); 
   FPRINTF(fp,"class array type int rank 1 shape 4 items %ld\n",nreg); 
   FPRINTF(fp,"data follows\n"); 
   temp=NULL; 
   while ((region = M_nextRegion(mesh,&temp)))
     { 
       list = R_vertices(region); 
       if (PList_size(list) != 4)
	 {
	   char s[80];
	   sprintf(s,"Can only handle tetrahedra\n");
	   pmdb_abort("part_write_dx",s);
	 }
       for(j=0; j < 4; j++) 
	 {
	   vertex = PList_item(list,j);
	   vnum = EN_dataI(vertex,TAG_DX_NUM) - 1; 
	   FPRINTF(fp," %d",vnum); 
	 }
       FPRINTF(fp,"\n"); 
       PList_delete(list);
     }
   FPRINTF(fp,"attribute \"element type\" string \"tetrahedra\"\n"); 
   FPRINTF(fp,"attribute \"ref\" string \"positions\"\n"); 

   /*
    * Proc Data (processor number for each element)
    */

   FPRINTF(fp,"#\n"); 
   FPRINTF(fp,"object \"procdat.%d\"\n",MYPID); 
   FPRINTF(fp,"class array type float rank 1 shape 1 items %ld\n",nreg); 
   FPRINTF(fp,"data follows\n"); 
   for(i=0; i < nreg; i++)
     FPRINTF(fp,"%d\n",MYPID); 
   FPRINTF(fp,"attribute \"dep\" string \"connections\"\n"); 

   /*
    * Optional cell file data
    */

   if (cellfile)
     {
       FPRINTF(fp,"#\n"); 
       FPRINTF(fp,"object \"cellfile.%d\"\n",MYPID); 
       FPRINTF(fp,"class array type float rank 1 shape %d items %ld\n",
	       celldim,nreg);
       FPRINTF(fp,"data file \"");
       FPRINTF(fp,cellfile,MYPID);
       FPRINTF(fp,"\"\n");
       FPRINTF(fp,"attribute \"dep\" string \"connections\"\n"); 
     }


   /*
    * Optional node file data
    */

   if (nodefile)
     {
       FPRINTF(fp,"#\n"); 
       FPRINTF(fp,"object \"nodefile.%d\"\n",MYPID); 
       FPRINTF(fp,"class array type float rank 1 shape %d items %ld\n",
	       nodedim,nvert);
       FPRINTF(fp,"data file \"");
       FPRINTF(fp,nodefile,MYPID);
       FPRINTF(fp,"\"\n");
       FPRINTF(fp,"attribute \"dep\" string \"positions\"\n"); 
     }


   /*
    * Put it all together in fields
    */


   FPRINTF(fp,"#\n");
   FPRINTF(fp,"### Fields for proc %d\n",MYPID); 
   FPRINTF(fp,"#\n"); 
   FPRINTF(fp,"object \"procfield.%d\" class field\n",MYPID);
   FPRINTF(fp,"component \"positions\"   value \"pos.%d\"\n",MYPID); 
   FPRINTF(fp,"component \"connections\" value \"con.%d\"\n",MYPID); 
   FPRINTF(fp,"component \"data\"        value \"procdat.%d\"\n",MYPID); 

   if (cellfile)
     {
       FPRINTF(fp,"#\n"); 
       FPRINTF(fp,"object \"cellfield.%d\" class field\n",MYPID);
       FPRINTF(fp,"component \"positions\"   value \"pos.%d\"\n",MYPID); 
       FPRINTF(fp,"component \"connections\" value \"con.%d\"\n",MYPID); 
       FPRINTF(fp,"component \"data\"        value \"cellfile.%d\"\n",MYPID);
     }

   if (nodefile)
     {
       FPRINTF(fp,"#\n"); 
       FPRINTF(fp,"object \"nodefield.%d\" class field\n",MYPID);
       FPRINTF(fp,"component \"positions\"   value \"pos.%d\"\n",MYPID); 
       FPRINTF(fp,"component \"connections\" value \"con.%d\"\n",MYPID); 
       FPRINTF(fp,"component \"data\"        value \"nodefile.%d\"\n",MYPID);
     }

   return(ret);
}



static int dx_write_group(
FILE   *fp, 
pMesh   mesh,
char    *cellfile,
char    *nodefile)
{
   int i; 
   int ret=0;                 /* SEE FPRINTF MACRO COMMENT */

   FPRINTF(fp,"#\n"); 
   FPRINTF(fp,"#################  Write composite fields  ########\n"); 

   FPRINTF(fp,"#\n"); 
   FPRINTF(fp,"object \"proc_compfield\"  compositefield\n"); 
   for(i=0; i < NUMPROCS; i++) 
     FPRINTF(fp,"member \"proc_compfield.%d\"  \"procfield.%d\"\n",i,i); 

   if (cellfile)
     {
       FPRINTF(fp,"#\n"); 
       FPRINTF(fp,"object \"cell_compfield\"  compositefield\n"); 
       for(i=0; i < NUMPROCS; i++) 
	 FPRINTF(fp,"member \"cell_compfield.%d\"  \"cellfield.%d\"\n",i,i); 
     }

   if (nodefile)
     {
       FPRINTF(fp,"#\n"); 
       FPRINTF(fp,"object \"node_compfield\"  compositefield\n"); 
       for(i=0; i < NUMPROCS; i++) 
	 FPRINTF(fp,"member \"node_compfield.%d\"  \"nodefield.%d\"\n",i,i); 
     }

   /* end of file */
   FPRINTF(fp,"#\n"); 
   FPRINTF(fp,"#\n"); 
   FPRINTF(fp,"end\n\n"); 

   return(ret);
}



static void dx_number_verts(pMesh   mesh)
{
   long    j;
   void   *temp;
   pVertex  t;
 
   temp = NULL;
   j = 1;
   while ((t = M_nextVertex(mesh,&temp)))
     {
       EN_attachDataI(t,TAG_DX_NUM,j);
       j++;
     }
}

static void dx_clean_verts(pMesh   mesh)
{
   void   *temp;
   pVertex  t;
 
   temp    = NULL;
   while ((t = M_nextVertex(mesh,&temp)))
     EN_removeData(t,TAG_DX_NUM);
}