void
avtGGCMFileFormat::PopulateDatabaseMetaData(avtDatabaseMetaData *md,
                                            int timeState)
{
    std::string meshname = "GGCM mesh";
    avtMeshType mt = AVT_RECTILINEAR_MESH;
    int nblocks = 1; /* must be 1 since this is an MTSD type dataset */
    int block_origin = 0;
    int spatial_dimension = 3;
    int topological_dimension = 3;
    double *extents = NULL;

    /** tell the MD object that we have a mesh */
    AddMeshToMetaData(md, meshname, mt, extents, nblocks, block_origin,
                      spatial_dimension, topological_dimension);


    avtCentering cent = AVT_NODECENT; /* node centered */
    int vector_dim = 3; /* 3 dimensional field */

    /* for large files, reading the metadata can actually take some time, for
     * technical reasons I won't expound.  On my system (7200rpm drives),
     * reading the metadata for a gigabyte file takes ~ 5 sec. */
    MHDdata *metadata = ggcm_read_metadata(this->GetFilename());

    std::vector<std::string> vectors;
    vectors = DeriveVectors(metadata);
    std::vector<std::string>::const_iterator iter;

    debug5 << vectors.size() << " vectors found in " << this->GetFilename()
           << std::endl;

    for(iter = vectors.begin(); iter != vectors.end(); iter++) {
        AddVectorVarToMetaData(md, (*iter).c_str(), meshname, cent, vector_dim);
    }

    std::vector<std::string> scalars;
    scalars = DeriveScalars(metadata);

    debug5 << scalars.size() << " scalars found in " << this->GetFilename()
           << std::endl;

    for(iter = scalars.begin(); iter != scalars.end(); iter++) {
        AddScalarVarToMetaData(md, (*iter).c_str(), meshname, cent);
    }
}
void
avtGTCFileFormat::PopulateDatabaseMetaData(avtDatabaseMetaData *md)
{
    // Add a point mesh
    std::string meshname = "particles";
    avtMeshMetaData *mmd = new avtMeshMetaData;
    mmd->name = meshname;
    mmd->spatialDimension = 3;
    mmd->topologicalDimension = 0;
    mmd->meshType = AVT_POINT_MESH;
#ifdef PARALLEL
    mmd->numBlocks = PAR_Size();
#endif
    md->Add(mmd);

    // Add scalar variables.
    for ( int i = 3; i < nVars; i++ )
    {
        std::string var = IndexToVarName( i );
        if ( var != "" )
            AddScalarVarToMetaData(md, var, meshname, AVT_NODECENT);        
    }
}
void
avtAdventureFileFormat::PopulateDatabaseMetaData(avtDatabaseMetaData *md)
{
    Initialize();

    // Add a mesh.
    std::string meshname = "mesh";
    int cellType = 0;
    avtMeshMetaData *mmd = new avtMeshMetaData;
    mmd->name = meshname;
    mmd->meshType = AVT_UNSTRUCTURED_MESH;
    mmd->spatialDimension = 3;
    mmd->topologicalDimension = 3;
    mmd->blockOrigin = 0;
    mmd->groupOrigin = 0;
    mmd->cellOrigin = 0;
    mmd->blockPieceName = "domain";
    mmd->blockTitle = "domains";

    if(usingAdvData)
    {
        mmd->numBlocks = advData.GetNumDomains();

        // Get the metadata from the ADV files.
        AdvDataSet::VarInfoVector  vars;
        AdvDataSet::AdvElementType elementType;
        advData.GetMetaData(vars, elementType);

        if(elementType == AdvDataSet::ADVENTURE_ELEMENT_TET4)
            cellType = 0;
        else if(elementType == AdvDataSet::ADVENTURE_ELEMENT_TET10)
            cellType = 1;
        else 
            cellType = 2;

        // Add variables that live on the mesh.
        for(size_t i = 0; i < vars.size(); ++i)
        {
            int ncomps = 1;
            if(vars[i].CheckFormat(ncomps))
            {
                if(vars[i].fega_type == "AllElementConstant" ||
                   vars[i].fega_type == "AllElementVariable")
                {
                    if(ncomps == 1)
                        AddScalarVarToMetaData(md, vars[i].label, meshname, AVT_ZONECENT);
                    else if(ncomps == 3)
                        AddVectorVarToMetaData(md, vars[i].label, meshname, AVT_ZONECENT);
                    else if(ncomps == 6)
                        AddSymmetricTensorVarToMetaData(md, vars[i].label, meshname, AVT_ZONECENT, 6);
                }
                else if(vars[i].fega_type == "AllNodeConstant" ||
                        vars[i].fega_type == "AllNodeVariable")
                {
                    // Skip node indexing variables since they are a little special.
                    if(vars[i].label == "NodeIndex_PartToGlobal" ||
                       vars[i].label == "NodeIndex_SubdomainToPart")
                        continue;

                    if(ncomps == 1)
                        AddScalarVarToMetaData(md, vars[i].label, meshname, AVT_NODECENT);
                    else if(ncomps == 3)
                        AddVectorVarToMetaData(md, vars[i].label, meshname, AVT_NODECENT);
                    else if(ncomps == 6)
                        AddSymmetricTensorVarToMetaData(md, vars[i].label, meshname, AVT_NODECENT, 6);
                }
            }
        }
    }
    else
    {
        mmd->numBlocks = mshData.GetNumDomains();
        cellType = mshData.GetCellType();
    }
    md->Add(mmd);

    // Store the cell type in the database comment so we know what it was.
    if(cellType == 0)
        md->SetDatabaseComment("Tet4 mesh");
    else if(cellType == 1)
        md->SetDatabaseComment("Tet10 mesh");
    else 
        md->SetDatabaseComment("Hex8 mesh");
}