common.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2016
 *
 * Cristián Maureira-Fredes <cmaureirafredes@gmail.com>
 *
 * All rights reserved.
 *
 * 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. The name of the author may not be used to endorse or promote
 * products derived from this software without specific prior written
 * permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 *
 */

#ifndef COMMON_HPP
#define COMMON_HPP

#if defined(_MPI)
#include <mpi.h>
#endif

#include <iomanip>
#include <iostream>
#include <ctime>
#include <cstdio>
#include <omp.h>
#include <cmath>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>


#if defined(_MPI)
#define MPI_NUM_SLAVES 600
#endif

#if defined(GPU)

#include <cuda_runtime.h>
#else

typedef struct double4
{
    double x, y, z, w;
} double4;

typedef struct double3
{
    double x, y, z;
} double3;
#endif

const int G = 1;

const int J = 6;

const float CORE_MASS = 0.1;

const float LAGRANGE_RADII[] = {0.01, 0.05, 0.1, 0.2, 0.5, 0.75};

const double E = 1e-4;

const double E2 = 1e-8;

const float ETA_S = 0.01;

const float ETA_N = 0.01;

const double D_TIME_MIN = 1.1920928955078125e-07;

//const double D_MTIME_MIN = 9.313225746154785e-10;
const double D_MTIME_MIN = 7.450580596923828e-09; // 2^-27

const double D_TIME_MAX = 0.125;

struct Distance
{
    int index;
    double value;
    bool operator<(const Distance& a) const
    {
        return value < a.value;
    }
};

typedef struct Energy
{
    double ini;
    double end;
    double tmp;
    double kinetic;
    double potential;
} Energy;

typedef struct options
{
    bool print_screen;
    bool print_all;
    bool print_lagrange;
} options;

typedef struct Predictor {
    double r[3];
    double v[3];
    float  m;
} Predictor;

typedef struct Forces {
    double a[3];
    double a1[3];
} Forces;

typedef struct Gtime {
    double integration_ini;
    double integration_end;

    double prediction_ini;
    double prediction_end;

    double update_ini;
    double update_end;

    double correction_ini;
    double correction_end;

    double grav_ini;
    double grav_end;

    double reduce_ini;
    double reduce_end;

    double reduce_forces_ini;
    double reduce_forces_end;

    float gflops;
    Gtime()
    {
        integration_ini = 0.0;
        integration_end = 0.0;
        prediction_ini = 0.0;
        prediction_end = 0.0;
        update_ini = 0.0;
        update_end = 0.0;
        correction_ini = 0.0;
        correction_end = 0.0;
        grav_ini = 0.0;
        grav_end = 0.0;
        reduce_ini = 0.0;
        reduce_end = 0.0;
        reduce_forces_ini = 0.0;
        reduce_forces_end = 0.0;
        gflops = 0.0;
    }
} Gtime;

typedef struct file_data
{
    int id;
    float m;
    double r[3];
    double v[3];
} file_data;

const double KERNEL_GFLOP = 48e-9; // 60e-9
#if defined(GPU)
const int BSIZE   = 32;
const int NJBLOCK = 16;
//#define KERNEL_ERROR_DEBUG 1
#endif

#endif