FONcGrid.cc

// FONcGrid.cc
 
// This file is part of BES Netcdf File Out Module
 
// Copyright (c) 2004,2005 University Corporation for Atmospheric Research
// Author: Patrick West <pwest@ucar.edu> and Jose Garcia <jgarcia@ucar.edu>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact University Corporation for Atmospheric Research at
// 3080 Center Green Drive, Boulder, CO 80301
 
// (c) COPYRIGHT University Corporation for Atmospheric Research 2004-2005
// Please read the full copyright statement in the file COPYRIGHT_UCAR.
//
// Authors:
//      pwest       Patrick West <pwest@ucar.edu>
//      jgarcia     Jose Garcia <jgarcia@ucar.edu>
 
#include <BESInternalError.h>
#include <BESDebug.h>
 
#include "FONcGrid.h"
#include "FONcUtils.h"
#include "FONcAttributes.h"

vector<FONcMap *> FONcGrid::Maps;

bool FONcGrid::InGrid = false;

FONcGrid::FONcGrid(BaseType *b) : FONcBaseType(), _grid(0), _arr(0)
{
    _grid = dynamic_cast<Grid *>(b);
    if (!_grid) {
        string s = (string) "File out netcdf, FONcGrid was passed a " + "variable that is not a DAP Grid";
        throw BESInternalError(s, __FILE__, __LINE__);
    }
}

FONcGrid::~FONcGrid()
{
    vector<FONcMap *>::iterator i = _maps.begin();
    while (i != _maps.end()) {
        // These are the FONc types, not DAP types
        (*i)->decref();
        ++i;
    }
 
    // Added jhrg 8/28/13
    delete _arr;
}

void FONcGrid::define(int ncid)
{
    if (!d_defined) {
        BESDEBUG("fonc", "FOncGrid::define - defining grid " << d_varname << endl);
 
        for (auto map: _maps)
            map->define(ncid);
 
        // Only define if this should be sent. jhrg 11/3/16
        if (_arr)
            _arr->define(ncid);
 
        d_defined = true;
 
        BESDEBUG("fonc", "FOncGrid::define - done defining grid " << d_varname << endl);
    }
}
 

void FONcGrid::convert(vector<string> embed, bool _dap4, bool is_dap4_group)
{
    FONcGrid::InGrid = true;
    FONcBaseType::convert(embed, _dap4, is_dap4_group);
    BESDEBUG("fonc", "FONcGrid:: version: '" << d_ncVersion << "'" << endl);
    d_varname = FONcUtils::gen_name(embed, d_varname, d_orig_varname);
    BESDEBUG("fonc", "FONcGrid::convert - converting grid " << d_varname << endl);
 
    // A grid has maps, which are single dimnension arrays, and an array
    // with one dimension for each map.
    Grid::Map_iter mi = _grid->map_begin();
    Grid::Map_iter me = _grid->map_end();
    for (; mi != me; mi++) {
 
        // Only add FONcBaseType instances to _maps if the Frid Map is
        // supposed to be sent. See Hyrax-282. jhrg 11/3/16
        if ((*mi)->send_p()) {
 
            Array *map = dynamic_cast<Array *>((*mi));
            if (!map) {
                string err = (string) "file out netcdf, grid " + d_varname + " map is not an array";
                throw BESInternalError(err, __FILE__, __LINE__);
            }
 
            vector<string> map_embed;
 
#if 0
            // Patch for HYRAX-1334 jhrg 2/14/24
            map->intern_data(*get_eval(), *get_dds());
#endif
            if (d_is_dap4 || get_eval() == nullptr || get_dds() == nullptr)
                map->intern_data();
            else
                map->intern_data(*get_eval(), *get_dds());
 
            FONcMap *map_found = FONcGrid::InMaps(map);
 
            // if we didn't find a match then found is still false. Add the
            // map to the vector of maps. If they are the same then create a
            // new FONcMap, add the grid name to the shared list and add the
            // FONcMap to the FONcGrid.
            if (!map_found) {
                FONcArray *fa = new FONcArray(map);
                fa->setVersion(d_ncVersion);
                fa->setNC4DataModel(d_nc4_datamodel);
                fa->convert(map_embed, _dap4,is_dap4_group);
                map_found = new FONcMap(fa, true);
                FONcGrid::Maps.push_back(map_found);
            }
            else {
                // it's the same ... we are sharing. Add the grid name fo
                // the list of grids sharing this map and set the embedded
                // name to empty, just using the name of the map.
                map_found->incref();
                map_found->add_grid(d_varname);
                map_found->clear_embedded();
            }
            _maps.push_back(map_found);
 
        }
    }
 
    // Only set _arr if the Grid Array should be sent. See Hyrax-282.
    // jhrg 11/3/16
    if (_grid->get_array()->send_p()) {
        _arr = new FONcArray(_grid->get_array());
        _arr->setVersion(d_ncVersion);
        _arr->setNC4DataModel(d_nc4_datamodel);
 
        _arr->convert(d_embed, _dap4, is_dap4_group);
    }
 
    BESDEBUG("fonc", "FONcGrid::convert - done converting grid " << d_varname << endl);
    FONcGrid::InGrid = false;
}

void FONcGrid::write(int ncid)
{
    BESDEBUG("fonc", "FOncGrid::define - writing grid " << d_varname << endl);
 
    // FONcBaseType instances are added only if the corresponding DAP variable
    // should be sent. See Hyrax-282. jhrg 11/3/16
    vector<FONcMap *>::iterator i = _maps.begin();
    vector<FONcMap *>::iterator e = _maps.end();
    for (; i != e; i++) {
        (*i)->write(ncid);
    }
 
    // only write this if is have been convert()ed and define()ed.
    // See above and Hyrax-282. jhrg  11/3/16
    if (_arr)
        _arr->write(ncid);
 
    d_defined = true;
 
    BESDEBUG("fonc", "FOncGrid::define - done writing grid " << d_varname << endl);
}

string FONcGrid::name()
{
    return _grid->name();
}

void FONcGrid::dump(ostream &strm) const
{
    strm << BESIndent::LMarg << "FONcGrid::dump - (" << (void *) this << ")" << endl;
    BESIndent::Indent();
    strm << BESIndent::LMarg << "name = " << _grid->name() << " { " << endl;
    BESIndent::Indent();
    strm << BESIndent::LMarg << "maps:";
    if (_maps.size()) {
        strm << endl;
        BESIndent::Indent();
        vector<FONcMap *>::const_iterator i = _maps.begin();
        vector<FONcMap *>::const_iterator e = _maps.end();
        for (; i != e; i++) {
            FONcMap *m = (*i);
            m->dump(strm);
        }
        BESIndent::UnIndent();
    }
    else {
        strm << " empty" << endl;
    }
    BESIndent::UnIndent();
    strm << BESIndent::LMarg << "}" << endl;
    strm << BESIndent::LMarg << "array:";
    if (_arr) {
        strm << endl;
        BESIndent::Indent();
        _arr->dump(strm);
        BESIndent::UnIndent();
    }
    else {
        strm << " not set" << endl;
    }
    BESIndent::UnIndent();
}
 
FONcMap *
FONcGrid::InMaps(Array *array)
{
    bool found = false;
    vector<FONcMap *>::iterator vi = FONcGrid::Maps.begin();
    vector<FONcMap *>::iterator ve = FONcGrid::Maps.end();
    FONcMap *map_found = 0;
    for (; vi != ve && !found; vi++) {
        map_found = (*vi);
        if (!map_found) {
            throw BESInternalError("map_found is null.", __FILE__, __LINE__);
        }
        found = map_found->compare(array);
    }
    if (!found) {
        map_found = 0;
    }
    return map_found;
}