tsgLoadNeededValues.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017, Miroslav Stoyanov
 *
 * This file is part of
 * Toolkit for Adaptive Stochastic Modeling And Non-Intrusive ApproximatioN: TASMANIAN
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions
 *    and the following disclaimer in the documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse
 *    or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * UT-BATTELLE, LLC AND THE UNITED STATES GOVERNMENT MAKE NO REPRESENTATIONS AND DISCLAIM ALL WARRANTIES, BOTH EXPRESSED AND IMPLIED.
 * THERE ARE NO EXPRESS OR IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, OR THAT THE USE OF THE SOFTWARE WILL NOT INFRINGE ANY PATENT,
 * COPYRIGHT, TRADEMARK, OR OTHER PROPRIETARY RIGHTS, OR THAT THE SOFTWARE WILL ACCOMPLISH THE INTENDED RESULTS OR THAT THE SOFTWARE OR ITS USE WILL NOT RESULT IN INJURY OR DAMAGE.
 * THE USER ASSUMES RESPONSIBILITY FOR ALL LIABILITIES, PENALTIES, FINES, CLAIMS, CAUSES OF ACTION, AND COSTS AND EXPENSES, CAUSED BY, RESULTING FROM OR ARISING OUT OF,
 * IN WHOLE OR IN PART THE USE, STORAGE OR DISPOSAL OF THE SOFTWARE.
 */
 
#ifndef __TASMANIAN_ADDONS_LOADNEEDEDVALS_HPP
#define __TASMANIAN_ADDONS_LOADNEEDEDVALS_HPP
 
#include "tsgAddonsCommon.hpp"
 
namespace TasGrid{
 
template<bool parallel_construction = true, bool overwrite_loaded = false>
void loadNeededValues(std::function<void(double const x[], double y[], size_t thread_id)> model, TasmanianSparseGrid &grid, size_t num_threads){
    int num_points = (overwrite_loaded) ? grid.getNumLoaded() : grid.getNumNeeded();
    int num_outputs = grid.getNumOutputs();
    if (grid.isUsingConstruction()) throw std::runtime_error("ERROR: cannot call loadNeededPoints() addon when isUsingConstruction() is true");
    if (num_outputs == 0) throw std::runtime_error("ERROR: cannot call loadNeededPoints() addon when the grid has no outputs");
    if (num_points == 0) return; // nothing to do here
    if (overwrite_loaded && (grid.getNumNeeded() != 0)) grid.clearRefinement(); // using loaded points only, clear the refinement
 
    // get the points and values
    auto points = (overwrite_loaded) ? grid.getLoadedPoints() : grid.getNeededPoints();
    std::vector<double> values(Utils::size_mult(num_points, num_outputs));
 
    // divide logically into strips
    Utils::Wrapper2D<double> xwrap(grid.getNumDimensions(), points.data());
    Utils::Wrapper2D<double> ywrap(num_outputs, values.data());
 
    if (parallel_construction && (num_threads > 0)){
        std::vector<bool> checked_out(num_points, false);
        std::mutex checked_out_lock;
 
        std::vector<std::thread> workers;
        workers.reserve(num_threads);
        for(size_t thread_id=0; thread_id<num_threads; thread_id++){
            workers.emplace_back( // create a new worker thread
                [&, thread_id](void)->void{
                    int sample = 0;
                    do{
                        { // find the next sample
                            std::lock_guard<std::mutex> lock(checked_out_lock);
                            while ((sample < num_points) && checked_out[sample]) sample++;
                            if (sample < num_points) checked_out[sample] = true;
                        }
                        if (sample < num_points) // if found, compute the next sample
                            model(xwrap.getStrip(sample), ywrap.getStrip(sample), thread_id);
                    }while(sample < num_points);
                }
            );
        }
 
        for(auto &w : workers) w.join(); // wait till finished
 
    }else{
        for(int i=0; i<num_points; i++)
            model(xwrap.getStrip(i), ywrap.getStrip(i), 0);
    }
 
    grid.loadNeededPoints(values);
}
 
template<bool parallel_construction = true, bool overwrite_loaded = false>
void loadNeededValues(std::function<void(std::vector<double> const &x, std::vector<double> &y, size_t thread_id)> model,
                      TasmanianSparseGrid &grid, size_t num_threads){
    int num_dimensions = grid.getNumDimensions();
    int num_outputs = grid.getNumOutputs();
    loadNeededValues<parallel_construction, overwrite_loaded>(
        [&](double const x[], double y[], size_t thread_id)->void{
            std::vector<double> vecy(num_outputs);
            model(std::vector<double>(x, x + num_dimensions), vecy, thread_id);
            std::copy(vecy.begin(), vecy.end(), y);
        }, grid, num_threads);
}
template<bool parallel_construction = true, bool overwrite_loaded = false>
void loadNeededPoints(std::function<void(double const x[], double y[], size_t thread_id)> model, TasmanianSparseGrid &grid, size_t num_threads){
    loadNeededValues<parallel_construction, overwrite_loaded>(model, grid, num_threads);
}
template<bool parallel_construction = true, bool overwrite_loaded = false>
void loadNeededPoints(std::function<void(std::vector<double> const &x, std::vector<double> &y, size_t thread_id)> model,
                      TasmanianSparseGrid &grid, size_t num_threads){
    loadNeededValues<parallel_construction, overwrite_loaded>(model, grid, num_threads);
}
 
}
 
#endif