Exemple #1
0
/* We examine all of Silo's data by traversing the all the "simple" arrays
   in the file. Ultimately, the data associated with all of Silo's abstract
   objects, excpet for object headers, is implemented in terms of simple
   arrays. This function finds all the simple arrays in the current dir
   and for each float or double array, reads it and examines it for NaNs.
   To avoid constantly allocating and freeing the buffers for arrays, we
   simply keep a growing buffer that grows to the largest array in the file
   and is freed only upon exit. We use Silo's non-allocating simple array
   read function. To make the loops for checking a NaN as fast as possible,
   we have two versions of the loop, one where progress is checked and 
   one where progress is not checked. We first examine all the simple
   arrays in the current dir, then we loop over subdirs and recurse */
static void
scanSiloDir(DBfile *siloFile, char *theDir)
{
   char **dirNames;
   int i,nDirs,nObjects;
   DBtoc *toc;

   DBNewToc(siloFile);
   toc = DBGetToc(siloFile);

   if (toc == NULL)
      return ;

   nObjects = toc->nvar + toc->ndir;

   if (!nObjects)
      return ;

   /* process the simple arrays in this dir */
   for (i = 0; i < toc->nvar; i++)
   {
      char *varName = toc->var_names[i];
      int n         = DBGetVarLength(siloFile, varName);
      int dbType    = DBGetVarType(siloFile, varName);
      int j;

      if (!disableVerbose)
      {
         if (dbType == DB_FLOAT || dbType == DB_DOUBLE)
            printf("CHECKING array %-56s\r", varName);
         else
            printf("skipping array %-56s\r", varName);
      }

      /* for float arrays */
      if (dbType == DB_FLOAT)
      {

         /* increase allocated buffer if necessary */
         if (n*sizeof(float) > fBufSize)
         {
            if (fBuf != NULL)
               free(fBuf);
            fBuf = (float *) malloc(n * sizeof(float));
            fBufSize = n;
         }

         DBReadVar(siloFile, varName, fBuf);

         if (disableProgress)
         {
            for (j = 0; j < n; j++)
               if (!IS_VALID_FLOAT(fBuf[j]))
                  handleInvalidValue(theDir, varName, j, (double) fBuf[j]);
         }
         else
         {
            for (j = 0; j < n; j++)
            {
               if (!IS_VALID_FLOAT(fBuf[j]))
                  handleInvalidValue(theDir, varName, j, (double) fBuf[j]);
               updateProgress(sizeof(float));
            }
         }
      }

      /* for double arrays */
      if (dbType == DB_DOUBLE)
      {
         /* increase allocated buffer if necessary */
         if (n*sizeof(double) > dBufSize)
         {
            if (dBuf != NULL)
               free(dBuf);
            dBuf = (double *) malloc(n * sizeof(double));
            dBufSize = n;
         }

         DBReadVar(siloFile, varName, dBuf);

         if (disableProgress)
         {
            for (j = 0; j < n; j++)
               if (!IS_VALID_DOUBLE(dBuf[j]))
                  handleInvalidValue(theDir, varName, j, dBuf[j]);
         }
         else
         {
            for (j = 0; j < n; j++)
            {
               if (!IS_VALID_DOUBLE(dBuf[j]))
                  handleInvalidValue(theDir, varName, j, dBuf[j]);
               updateProgress(sizeof(double));
            }
         }
      }
   } /* for i */

   /* save off the dir-stuff out of the toc so we don't loose it during the
      recursions */
   nDirs = toc->ndir;
   dirNames = (char **) malloc(nDirs * sizeof(char*));
   for (i = 0; i < nDirs; i++)
   {
      dirNames[i] = (char *) malloc(strlen(toc->dir_names[i])+1);
      strcpy(dirNames[i], toc->dir_names[i]);
   }

   /* recurse on any subdirs */
   for (i = 0; i < nDirs; i++)
   {
      DBSetDir(siloFile, dirNames[i]);
      scanSiloDir(siloFile, dirNames[i]); 
      DBSetDir(siloFile, "..");
      free(dirNames[i]);
   }

   /* free the dir-stuff we set aside */
   free(dirNames);

}
Exemple #2
0
void perform_merge(
    hpx::lcos::local::channel<void>& sync
  , DBfile* file 
  , std::vector<std::string> const& directory_names
  , std::string const& variable_name 
  , boost::uint64_t& step
  , double& time
    )
{ // {{{
    for (boost::uint64_t level = 0; level < directory_names.size(); ++level)
    {
        int error = DBSetDir(file, directory_names[level].c_str());
        OCTOPUS_ASSERT(error == 0);
    
        // Get a list of all the meshes and variables in that directory.
        DBtoc* contents = DBGetToc(file);

        // Make the mesh and variable names.
        boost::ptr_vector<char> mesh_names(contents->nqmesh);
        boost::ptr_vector<char> variable_names(contents->nqmesh);
        
        double grid_dim = config().spatial_domain;

        for (boost::uint64_t i = 1; i < level; ++i)
            grid_dim *= 0.5;

        for (boost::uint64_t j = 0; j < boost::uint64_t(contents->nqmesh); ++j)
        {
            std::string tmp;

            ///////////////////////////////////////////////////////////////////
            tmp  = directory_names[level];
            tmp += "/";
            tmp += contents->qmesh_names[j];

            // The extra character is for the terminating byte.
            mesh_names.push_back(new char[tmp.size() + 1]);
            std::strcpy(&mesh_names[j], tmp.c_str());

            ///////////////////////////////////////////////////////////////////
            tmp  = directory_names[level];
            tmp += "/";
            tmp += contents->qvar_names[j];

            // The extra character is for the terminating byte.
            variable_names.push_back(new char[tmp.size() + 1]);
            std::strcpy(&variable_names[j], tmp.c_str());
        }

        // when we change directories below, "contents" will go out of scope
        boost::uint64_t nqmesh = contents->nqmesh;

        error = DBSetDir(file, "/");
        OCTOPUS_ASSERT(error == 0);

        std::string multi_mesh_name
            = boost::str( boost::format("mesh_level_%1%")
                        % level);

        std::string multi_variable_name
            = boost::str( boost::format("%1%_level_%2%")
                        % variable_name % level); 


        {
            DBoptlist* optlist = DBMakeOptlist(4);
            DBObjectType type1 = DB_QUADRECT;
            DBAddOption(optlist, DBOPT_MB_BLOCK_TYPE, &type1);
            DBAddOption(optlist, DBOPT_CYCLE, &step);
            DBAddOption(optlist, DBOPT_DTIME, &time);

            error = DBPutMultimesh(file
                                 , multi_mesh_name.c_str()
                                 , nqmesh
                                 , mesh_names.c_array()
                                 , NULL, optlist);
            OCTOPUS_ASSERT(error == 0);
        }

        {
            DBoptlist* optlist = DBMakeOptlist(4);
            DBObjectType type1 = DB_QUADVAR;
            DBAddOption(optlist, DBOPT_MB_BLOCK_TYPE, &type1);
            DBAddOption(optlist, DBOPT_CYCLE, &step);
            DBAddOption(optlist, DBOPT_DTIME, &time);
            int type2 = DB_ROWMAJOR;
            DBAddOption(optlist, DBOPT_MAJORORDER, &type2);

            error = DBPutMultivar(file
                                , multi_variable_name.c_str()
                                , nqmesh
                                , variable_names.c_array()
                                , NULL, optlist);
            OCTOPUS_ASSERT(error == 0);
        }
    }

    sync.post();
} // }}}
Exemple #3
0
/*-------------------------------------------------------------------------
 * Function:	test_dirs
 *
 * Purpose:	Test directory operations
 *
 * Return:	Success:	0
 *
 *		Failure:	number of errors
 *
 * Programmer:	Robb Matzke
 *              Wednesday, February 10, 1999
 *
 * Modifications:
 *		Robb Matzke, 2000-01-12
 *		Changed hyphens to underscores in object names because silo
 *		now fails when underscores are present in the name.
 *-------------------------------------------------------------------------
 */
static int
test_dirs(DBfile *dbfile)
{
    int		nerrors=0;
    char	curdir[1024];
    static int	in[1]={911}, value[1]={0};
    static int	dims[1]={1};

    puts("=== Directories ===");

    /* Make some directories */
    if (DBMkDir(dbfile, "dir1")<0) {
	puts("DBMkDir(dir1) failed");
	nerrors++;
    }
    if (DBMkDir(dbfile, "dir1/d1a")<0) {
	puts("DBMkDir(dir1/d1a) failed");
	nerrors++;
    }
    if (DBMkDir(dbfile, "/dir1/d1b")<0) {
	puts("DBMkDir(dir1/d1b) failed");
	nerrors++;
    }
    if (DBMkDir(dbfile, "/dir1/d1c/")<0) {
	puts("DBMkDir(dir1/d1c) failed");
	nerrors++;
    }
    if (DBMkdir(dbfile, "//dir2//")<0) {
	puts("DBMkDir(dir2) failed");
	nerrors++;
    }

    /* Set the CWD to /dir1/d1c and write a variable */
    if (DBSetDir(dbfile, "//dir1//d1c//")<0) {
	puts("DBSetDir(/dir1/d1c) failed");
	nerrors++;
    }
    if (DBWrite(dbfile, "d1c_A", value, dims, 1, DB_INT)<0) {
	puts("DBWrite(d1c_A) failed");
	nerrors++;
    }
    if (DBGetDir(dbfile, curdir)<0 || strcmp(curdir, "/dir1/d1c")) {
	puts("DBGetDir() failed");
	nerrors++;
    }
    if (DBReadVar(dbfile, "../d1c/..//..////dir1/d1c//d1c_A", in)<0 ||
	in[0]!=value[0]) {
	puts("DBReadVar(d1c_A) failed");
	nerrors++;
    }

    /* Test table of contents */
    if (NULL==DBGetToc(dbfile)) {
	puts("DBGetToc() failed");
	nerrors++;
    }
    
    /* Set CWD to top */
    if (DBSetDir(dbfile, "/")<0) {
	puts("DBSetDir(/) failed");
	nerrors++;
    }
    if (DBGetDir(dbfile, curdir)<0 || strcmp(curdir, "/")) {
	puts("DBetDir() failed");
	nerrors++;
    }

    return nerrors;
}
Databox         *ReadSilo(char *filename, double default_value)
{
#ifdef HAVE_SILO
   Databox         *v;

   double          X,  Y,  Z;
   int             NX, NY, NZ;
   double          DX, DY, DZ;

   int             x,  y,  z;
   int             nx, ny, nz;

   int             j, k;

   double         *ptr;
   
   int             err = -1;

   DBfile         *db;
    double         epsi = 1.0E-16;
   char *current_path = NULL;
   char *path = NULL;
   char *slash = strchr(filename, '/');
    float *localcoords[3];
    
   if(slash) {
      path = (char *)malloc(MAXPATHLEN);
      strncpy(path, filename, slash - filename);
      path[slash - filename] = 0;
      filename = strdup(slash + 1);
   } else {
      filename = strdup(filename);
   }

   if(path) { 	
      current_path = (char *)malloc(MAXPATHLEN);
      getwd(current_path);
      chdir(path);
   }

//   db = DBOpen(filename, DB_PDB, DB_READ);
   db = DBOpen(filename, DB_UNKNOWN, DB_READ);
   if(db == NULL)
   {
      printf("Failed to open SILO file %s\n", filename);
      return NULL;
   }

   double origin[3];
   err = DBReadVar(db, "origin", &origin);
   if(err < 0) {
      printf("Failed to read meta data\n");
      return NULL;
   } 
   X = origin[0];
   Y = origin[1];
   Z = origin[2];

   int size[3];
   err = DBReadVar(db, "size", &size);
   if(err < 0) {
      printf("Failed to read meta data\n");
      return NULL;
   } 
   NX = size[0];
   NY = size[1];
   NZ = size[2];

   double delta[3];
   err = DBReadVar(db, "delta", &delta);
   if(err < 0) {
      printf("Failed to read meta data\n");
      return NULL;
   } 
   DX = delta[0];
   DY = delta[1];
   DZ = delta[2];

   /* create the new databox structure */
   if ((v = NewDataboxDefault(NX, NY, NZ, X, Y, Z, DX, DY, DZ, default_value)) == NULL)
   {
      return((Databox *)NULL);
   }

   DBtoc *toc = DBGetToc(db);
   if ( toc == NULL ) {      
      printf("Error: Silo get get TOC failed for %s\n", filename);
      return NULL;
   }

   char **multivar_names = toc -> multivar_names;
   int    nmultivar      = toc -> nmultivar;

    /* Check to see if file has a multivar in it to determine file format being used */
   if(nmultivar == 0) 
   {
      DBquadvar  *var = DBGetQuadvar(db, "variable");
      if(var == NULL) 
      {
	 printf("Error: Silo failed to get quadvar %s \n", "variable");
	 return NULL;
      }

      memcpy(DataboxCoeff(v, 0, 0, 0), var -> vals[0], NX*NY*NZ * sizeof(double));

      DBFreeQuadvar(var);

   } else {

      DBmultivar *multivar = DBGetMultivar(db, multivar_names[0]);
      if ( multivar == NULL ) {      
	 printf("Error: Silo get multivar failed for %s\n", multivar_names[0]);
	 return NULL;
      }
      
      
      int    nvars         = multivar -> nvars;  
      char **varnames      = multivar -> varnames;
      
      int i;

      int m;
      for(m = 0; m < nvars; m++) 
      {
	 char *proc_filename;
	 char *seperator = ":";
      
	 proc_filename = strtok(varnames[m], seperator);
	 char *proc_varname;
	 proc_varname = strtok(NULL, seperator);
        /*  printf("multivar nvar:  %d  \n", nvars);
          printf("multivar proc_varname:  %s  \n", proc_varname);
          printf("multivar proc_filename:  %s  \n", proc_filename); */

	 if(proc_filename == NULL)
	 {
	    printf("Error malformed multivar name %s in SILO file \n", varnames[m]);
	    return NULL;
	 }
      
	 DBfile *proc_db;
//	 proc_db = DBOpen(proc_filename, DB_PDB, DB_READ);
	 proc_db = DBOpen(proc_filename, DB_UNKNOWN, DB_READ);
	 if(db == NULL)
	 {
	    printf("Failed to open SILO file %s\n", filename);
	    return NULL;
	 }
      
	 if(proc_varname == NULL)
	 {
	    printf("Error malformed multivar name %s in SILO file \n", varnames[m]);
	    return NULL;
	 }

	 DBquadvar  *var = DBGetQuadvar(proc_db, proc_varname);
	 if(var == NULL) 
	 {
	    printf("Error: Silo failed to get quadvar %s \n", varnames[m]);
	    return NULL;
	 }

          /* now we need to get the mesh, for PMPIO compat */
	 DBquadmesh  *mesh = DBGetQuadmesh(proc_db, var -> meshname);
	 if(mesh == NULL) 
	 {
	    printf("Error: Silo failed to get quadmesh %s \n", varnames[m]);
	    return NULL;
	 }        
	 
	 nx = var -> dims[0];
	 ny = var -> dims[1];
	 nz = var -> dims[2];

	 /* Casting here is a dangerous */
	 localcoords[0] = (float *)mesh -> coords[0];
	 localcoords[1] = (float *)mesh -> coords[1];
	 localcoords[2] = (float *)mesh -> coords[2];
	  
	 int index_origin[3];
	 err = DBReadVar(proc_db, "index_origin", &index_origin);
	 if(err < 0) {
	    printf("Failed to read meta data\n");
	    return NULL;
	 }  

	 /* becuase of multi or single file compatibility we need to 
	  * grab the actual mesh from that variable.  Then we need to
	  * determine the origin from the mesh[0][0], [1][0] and [2][0]
	  * divided by DX, DY and DZ since there are multiple origins 
	  * in a single file and this is now ambiguous. */
	 
	 x = index_origin[0];
	 y = index_origin[1];
	 z = index_origin[2];
	 
	 x = round( (localcoords[0][0] - (X - DX / 2.0))  / DX);
	 y = round( (localcoords[1][0] - (Y - DY / 2.0))  / DY);
	 z = round( (localcoords[2][0] - (Z - DZ / 2.0))  / DZ);
	 int index = 0;
	 double *vals =  (double *)var -> vals[0];
	 for (k = 0; k < nz; k++) {
	    for (j = 0; j < ny; j++) {
	       for (i = 0; i < nx; i++) {
		  ptr = DataboxCoeff(v, x + i, y + j, z + k);
		  *ptr = vals[index];
               index++;
	       }
	    }
	 }

	 DBFreeQuadvar(var);
     
	 DBClose(proc_db);
      }

      DBFreeMultivar(multivar);
   }


   DBClose(db);

    

   if(path) { 	
      free(path);
   }

   if(current_path) { 	
      chdir(current_path);
      free(current_path);
   }

   free(filename);
 /*   free(localcoords[0]);
    free(localcoords[1]);
    free(localcoords[2]); */
    
   return v;
#else

#endif

}