Add file output.

#include "../graph_framework/timing.hpp"

//------------------------------------------------------------------------------

///  @brief Main program of the driver.

///  @brief Run Korc

///

///  @param[in] argc Number of commandline arguments.

///  @param[in] argv Array of commandline arguments.

///  @tparam T Base type.

//------------------------------------------------------------------------------

int main(int argc, const char * argv[]) {

    START_GPU

    (void)argc;

    (void)argv;

template<jit::float_scalar T>

void run_korc() {

    const timeing::measure_diagnostic t_total("Total Time");

    const size_t num_particles = 10000000;

    const size_t num_particles = 1;

    std::cout << "Num particles " << num_particles << std::endl;

    std::vector<std::thread> threads(std::max(std::min(static_cast<unsigned int> (jit::context<double>::max_concurrency()),

    std::vector<std::thread> threads(std::max(std::min(static_cast<unsigned int> (jit::context<T>::max_concurrency()),

                                                       static_cast<unsigned int> (num_particles)),

                                              static_cast<unsigned int> (1)));

            const timeing::measure_diagnostic t_setup("Setup Time");

            auto eq = equilibrium::make_efit<double> (EFIT_FILE);

            //auto eq = equilibrium::make_slab_density<double> ();

            auto eq = equilibrium::make_efit<T> (EFIT_FILE);

            //auto eq = equilibrium::make_slab_density<T> ();

            auto b0 = eq->get_characteristic_field(thread_number);

            const double q = 1.602176634E-19;

            const double me = 9.1093837139E-31;

            const double c = 299792458.0;

            const T q = 1.602176634E-19;

            const T me = 9.1093837139E-31;

            const T c = 299792458.0;

            auto gryo_period = me/(q*b0);

            std::cout << "gryo_period " << gryo_period->evaluate().at(0) << std::endl;

            std::cout << "Local num particles " << local_num_particles << std::endl;

            auto ux = graph::variable<double> (local_num_particles, "u_{x}");

            auto uy = graph::variable<double> (local_num_particles, "u_{y}");

            auto uz = graph::variable<double> (local_num_particles, "u_{z}");

            auto ux = graph::variable<T> (local_num_particles, "u_{x}");

            auto uy = graph::variable<T> (local_num_particles, "u_{y}");

            auto uz = graph::variable<T> (local_num_particles, "u_{z}");

            ux->set(0.99);

            uy->set(0.0);

            uz->set(0.0);

            ux->set(0.0);

            uy->set(0.99);

            uz->set(0.1);

            auto x = graph::variable<double> (local_num_particles, "x");

            auto y = graph::variable<double> (local_num_particles, "y");

            auto z = graph::variable<double> (local_num_particles, "z");

            auto x = graph::variable<T> (local_num_particles, "x");

            auto y = graph::variable<T> (local_num_particles, "y");

            auto z = graph::variable<T> (local_num_particles, "z");

            auto pos = graph::vector(x, y, z);

            x->set(1.7);

            auto u_vec = graph::vector(ux, uy, uz);

            auto gamma = graph::variable<double> (local_num_particles, "\\gamma");

            auto gamma = graph::variable<T> (local_num_particles, "\\gamma");

            auto dt = graph::constant<double> (0.25);

            auto dt = graph::constant<T> (0.25);

            auto gamma_init = 1.0/graph::sqrt(1.0 - u_vec->dot(u_vec));

                                                pos->get_y(),

                                                pos->get_z())/b0;

            workflow::manager<double> work(thread_number);

            workflow::manager<T> work(thread_number);

            work.add_preitem({

                graph::variable_cast(ux),

                graph::variable_cast(uy),

            }, "step");

            work.compile();

            std::ostringstream stream;

            stream << "korc_" << thread_number << ".nc";

            output::result_file file(stream.str(), local_num_particles);

            output::data_set<T> dataset(file);

            dataset.create_variable(file, "x",     x,     work.get_context());

            dataset.create_variable(file, "y",     y,     work.get_context());

            dataset.create_variable(file, "z",     z,     work.get_context());

            dataset.create_variable(file, "ux",    ux,    work.get_context());

            dataset.create_variable(file, "uy",    uy,    work.get_context());

            dataset.create_variable(file, "uz",    uz,    work.get_context());

            dataset.create_variable(file, "gamma", gamma, work.get_context());

            file.end_define_mode();

            std::thread sync([]{});

            t_setup.print();

            const timeing::measure_diagnostic t_run("Run Time");

            work.pre_run();

            for (size_t i = 0; i < 1000000; i++) {

                sync.join();

                work.wait();

                sync = std::thread([&file, &dataset] () -> void {

                    dataset.write(file);

                });

                work.run();

            }

            sync.join();

            dataset.write(file);

            work.wait();

            t_run.print();

        }, i);

    }

    std::cout << std::endl << "Timing:" << std::endl;

    t_total.print();

}

//------------------------------------------------------------------------------

///  @brief Main program of the driver.

///

///  @param[in] argc Number of commandline arguments.

///  @param[in] argv Array of commandline arguments.

//------------------------------------------------------------------------------

int main(int argc, const char * argv[]) {

    START_GPU

    (void)argc;

    (void)argv;

    run_korc<double> ();

    END_GPU

}