ProblemSetup.h

Go to the documentation of this file.

/*
 *  This file is part of AQUAgpusph, a free CFD program based on SPH.
 *  Copyright (C) 2012  Jose Luis Cercos Pita <jl.cercos@upm.es>
 *
 *  AQUAgpusph is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  AQUAgpusph 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with AQUAgpusph.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef PROBLEMSETUP_H_INCLUDED
#define PROBLEMSETUP_H_INCLUDED
 
#define __NO_OUTPUT_MODE__ 0
#define __FPS_MODE__ 1 << 0
#define __IPF_MODE__ 1 << 1
#define __TIME_MODE__ 1 << 0
#define __ITER_MODE__ 1 << 1
#define __FRAME_MODE__ 1 << 2
 
#include <sphPrerequisites.h>
 
#include <math.h>
#include <string>
#include <vector>
#include <vector>
#include <map>
 
#if __APPLE__
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
 
namespace Aqua {
namespace InputOutput {
 
class ProblemSetup
{
  public:
        ProblemSetup();
 
        ProblemSetup(const ProblemSetup& p);
 
        ~ProblemSetup();
 
        class sphSettings
        {
          public:
                sphSettings();
                ~sphSettings(){};
 
                bool save_on_fail;
 
                bool debug_tools;
 
                std::string base_path;
 
                class device
                {
                  public:
                        device(const unsigned int platform_index,
                               const unsigned int device_index,
                               const cl_device_type t = CL_DEVICE_TYPE_ALL)
                          : platform_id(platform_index)
                          , device_id(device_index)
                          , device_type(t){};
 
                        ~device(){};
 
                        unsigned int platform_id;
 
                        unsigned int device_id;
 
                        cl_device_type device_type;
                };
 
                std::vector<ProblemSetup::sphSettings::device> devices;
        };
 
        sphSettings settings;
 
        class sphVariables
        {
          public:
                sphVariables(){};
                ~sphVariables(){};
 
                std::vector<std::string> names;
                std::vector<std::string> types;
                std::vector<std::string> lengths;
                std::vector<std::string> values;
 
                void registerVariable(std::string name,
                                      std::string type,
                                      std::string length,
                                      std::string value);
        };
 
        sphVariables variables;
 
        struct sphDefinitions
        {
                sphDefinitions(){};
                ~sphDefinitions(){};
 
                std::vector<std::string> names;
                std::vector<std::string> values;
                std::vector<bool> evaluations;
 
                void define(const std::string name,
                            const std::string value,
                            const bool evaluate);
 
                bool isDefined(std::string name);
 
                void undefine(std::string name);
        };
 
        sphDefinitions definitions;
 
        class sphTool
        {
          public:
                sphTool(){};
 
                ~sphTool(){};
 
                void set(const std::string name, const std::string value);
 
                const std::string get(const std::string name);
 
                const std::string get(unsigned int index);
 
                const std::string getName(unsigned int index);
 
                unsigned int n() const { return _data.size(); }
 
          private:
                bool has(const std::string name);
 
                std::map<std::string, std::string> _data;
        };
 
        std::vector<sphTool*> tools;
 
        unsigned int toolInstances(ProblemSetup::sphTool* tool);
 
        std::vector<sphTool*> reports;
 
        struct sphTimingParameters
        {
                unsigned int sim_end_mode;
 
                float sim_end_time;
 
                int sim_end_step;
 
                int sim_end_frame;
 
                unsigned int output_mode;
 
                float output_fps;
 
                int output_ipf;
 
                unsigned int dt_mode;
        } time_opts;
 
        class sphParticlesSet
        {
          public:
                sphParticlesSet();
 
                ~sphParticlesSet();
 
                void n(unsigned int N) { _n = N; }
 
                unsigned int n() const { return _n; }
 
                void addScalar(std::string name, std::string value);
 
                std::vector<std::string> scalarNames() const { return _snames; }
 
                std::vector<std::string> scalarValues() const { return _svalues; }
 
                void input(std::string path, std::string format, std::string fields);
 
                const std::string inputPath() const { return _in_path; }
 
                const std::string inputFormat() const { return _in_format; }
 
                std::vector<std::string> inputFields() const { return _in_fields; }
 
                void output(std::string path, std::string format, std::string fields);
 
                const std::string outputPath() const { return _out_path; }
 
                const std::string outputFormat() const { return _out_format; }
 
                std::vector<std::string> outputFields() const { return _out_fields; }
 
          private:
                unsigned int _n;
 
                std::vector<std::string> _snames;
                std::vector<std::string> _svalues;
 
                std::string _in_path;
 
                std::string _in_format;
 
                std::vector<std::string> _in_fields;
 
                std::string _out_path;
 
                std::string _out_format;
 
                std::vector<std::string> _out_fields;
        };
 
        std::vector<sphParticlesSet*> sets;
 
  private:
        bool _copy;
};
 
}
} // namespace
 
#endif // PROBLEMSETUP_H_INCLUDED