/* ----------------------------------------------------------------------
   LIGGGHTS - LAMMPS Improved for General Granular and Granular Heat
   Transfer Simulations

   LIGGGHTS is part of the CFDEMproject
   www.liggghts.com | www.cfdem.com

   Christoph Kloss, christoph.kloss@cfdem.com
   Copyright 2009-2012 JKU Linz
   Copyright 2012-     DCS Computing GmbH, Linz

   LIGGGHTS is based on LAMMPS
   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
   http://lammps.sandia.gov, Sandia National Laboratories
   Steve Plimpton, sjplimp@sandia.gov

   This software is distributed under the GNU General Public License.

   See the README file in the top-level directory.
------------------------------------------------------------------------- */

/* ----------------------------------------------------------------------
   Contributing authors:
   Stefan Amberger (JKU Linz)
------------------------------------------------------------------------- */

#include "modified_andrew.h"
#include "mpi_liggghts.h"
#include "vector_liggghts.h"
#include "error.h"
#include "comm.h"
/*NL*/ // #include "update.h"

#include <algorithm>
#include <cmath>
#include <vector>

using MODIFIED_ANDREW_AUX::Circle;
using MODIFIED_ANDREW_AUX::Point;
using namespace LAMMPS_NS;
using namespace std;

/* ---------------------------------------------------------------------- */

ModifiedAndrew::ModifiedAndrew(LAMMPS *lmp) : Pointers(lmp) {
  npoints_per_circle_ = 6;
  directions_ = new double*[npoints_per_circle_];
  for (int i = 0; i < npoints_per_circle_; ++i)
  {
    directions_[i] = new double[2];
  }
  double angle = (2.0*M_PI)/((double)npoints_per_circle_);
  for (int i = 0; i < npoints_per_circle_; ++i)
  {
    directions_[i][0] = sin(((double)i)*angle);
    directions_[i][1] = cos(((double)i)*angle);
  }

  /*NL*/ // // DEBUG
  /*NL*/ // for (int j = 0; j < comm->nprocs; ++j)
  /*NL*/ // {
  /*NL*/ //   if (comm->me == j){
  /*NL*/ //     printf("directions proc %d:\n",comm->me);
  /*NL*/ //     for (int i = 0; i < npoints_per_circle_; ++i)
  /*NL*/ //       printf("(%f %f)\n", directions_[i][0],directions_[i][1]);
  /*NL*/ //     }
  /*NL*/ //   MPI_Barrier(world);
  /*NL*/ // }
  /*NL*/ // // END DEBUG

}
ModifiedAndrew::~ModifiedAndrew(){
  for (int i = 0; i < npoints_per_circle_; ++i)
    delete []directions_[i];
  delete []directions_;
}

/* ---------------------------------------------------------------------- */

double ModifiedAndrew::area()
{
    double A;
    vector<Point> hull_c = convex_hull(contacts_);

    /*NL*/ //if (screen) {
    /*NL*/ //fprintf(screen,"hull_c size %d\n",hull_c.size());
    /*NL*/ //for(int i = 0; i < hull_c.size(); i++)
    /*NL*/ //  fprintf(screen,"element %d: %f %f %f\n",i,hull_c[i].x,hull_c[i].y,hull_c[i].r);
    /*NL*/ //}

    // multi-proc case
    if(1 < comm->nprocs) //(1)//
    {
      /*NL*/ // // DEBUG
      /*NL*/ // for (int i = 0; i < comm->nprocs; ++i)
      /*NL*/ // {
      /*NL*/ //   if (comm->me == i)
      /*NL*/ //   {
      /*NL*/ //     printf("contacts_%d=[\n", i);
      /*NL*/ //     for (int j = 0; j < contacts_.size(); ++j)
      /*NL*/ //     {
      /*NL*/ //       printf("(%f, %f),\n", contacts_[j].x, contacts_[j].y);
      /*NL*/ //     }
      /*NL*/ //     printf("]\n");
      /*NL*/ //     fflush(stdout);
      /*NL*/ //   }
      /*NL*/ //   MPI_Barrier(world);
      /*NL*/ // }
      /*NL*/ //   MPI_Barrier(world);
      /*NL*/ // // END DEBUG

      /*NL*/ //  // DEBUG
      /*NL*/ //  for (int i = 0; i < comm->nprocs; ++i)
      /*NL*/ //  {
      /*NL*/ //    if (comm->me == i)
      /*NL*/ //    {
      /*NL*/ //      printf("hull_c%d=[\n", i);
      /*NL*/ //      for (int j = 0; j < hull_c.size(); ++j)
      /*NL*/ //      {
      /*NL*/ //        printf("(%f, %f),\n", hull_c[j].x, hull_c[j].y);
      /*NL*/ //      }
      /*NL*/ //      printf("]\n");
      /*NL*/ //      fflush(stdout);
      /*NL*/ //    }
      /*NL*/ //    MPI_Barrier(world);
      /*NL*/ //  }
      /*NL*/ //    MPI_Barrier(world);
      /*NL*/ //  // END DEBUG


        // perform allgather
        double *data = 0,*data0 = 0;
        int ndata = 0, ndata0 = 0;

        //NP erase first element which is duplicate
        if(hull_c.size() > 2)
            hull_c.erase(hull_c.begin());

        // copy from STL vector to C array to safely use MPI
        ndata = construct_data(hull_c,data);
        ndata0 = MPI_Gather0_Vector(data,ndata,data0,world);

        /*NL*///if (screen) printVecN(screen,"data",data,ndata);
        /*NL*///if (screen) printVecN(screen,"data0",data0,ndata0);

        // proc0 calculates convex hull
        if(0 == comm->me) {

            vector<Point> hull_c_allreduced = construct_hull_c_all(data0,ndata0);
            vector<Point> hull_c_global = convex_hull(hull_c_allreduced);

            /*NL*/ //  // DEBUG
            /*NL*/ //      printf("hull_c_global=[\n");
            /*NL*/ //      for (int j = 0; j < hull_c_global.size(); ++j)
            /*NL*/ //        printf("(%f, %f),\n", hull_c_global[j].x, hull_c_global[j].y);
            /*NL*/ //      printf("]\n");
            /*NL*/ //      fflush(stdout);
            /*NL*/ //  // END DEBUG


            /*NL*/ //if (screen) {
            /*NL*/ //fprintf(screen,"hull_c_allreduced size %d\n",hull_c_allreduced.size());
            /*NL*/ //for(int i = 0; i < hull_c_allreduced.size(); i++)
            /*NL*/ //  fprintf(screen,"element %d: %f %f %f\n",i,hull_c_allreduced[i].x,hull_c_allreduced[i].y,hull_c_allreduced[i].r);
            /*NL*/ //}

            if (hull_c_global.size() < 3)
                A = 0.;
            else
                A = area(hull_c_global);
        }
        /*NL*/ // // DEBUG
        /*NL*/ // MPI_Barrier(world);
        /*NL*/ // // END DEBUG

        if(data) delete []data;
        if(data0) delete []data0;

        /*NL*/ // // DEBUG
        /*NL*/ // for (int i = 0; i < comm->nprocs; ++i)
        /*NL*/ // {
        /*NL*/ //   if (comm->me == i)
        /*NL*/ //     printf("A%d=%f\n", i, A);
        /*NL*/ //   MPI_Barrier(world);
        /*NL*/ // }
        /*NL*/ //   MPI_Barrier(world);
        /*NL*/ // // END DEBUG


        // broadcast result
        MPI_Bcast(&A,1,MPI_DOUBLE,0,world);
    }
    // single proc case
    else
    {
        if (hull_c.size() < 3)
           A = 0.;
        else
            A = area(hull_c);
    }

    // clear contact data
    contacts_.clear();

    /*NL*/ // DEBUG
    /*NL*/ // if (update->ntimestep == 5000)
    /*NL*/ //   error->all(FLERR, "reached timestep 5000");
    /*NL*/ // END DEBUG

    return A;
}

/* ---------------------------------------------------------------------- */

void ModifiedAndrew::add_contact(Circle c){
  // generate npoints_per_circle_ points for this circle
  Point p;
  for (int i = 0; i < npoints_per_circle_; ++i)
  {
    p.x = c.x+directions_[i][0]*c.r;
    p.y = c.y+directions_[i][1]*c.r;
    contacts_.push_back(p);
  }
}

/* ---------------------------------------------------------------------- */

int ModifiedAndrew::construct_data(vector<Point> hull_c, double *&data)
{
    int size = hull_c.size();
    int datasize = 2*size;
    data = new double[datasize];

    for(int i = 0; i < size; i++)
    {
        data[2*i+0] = hull_c[i].x;
        data[2*i+1] = hull_c[i].y;
    }

    return datasize;
}

/* ---------------------------------------------------------------------- */

vector<Point> ModifiedAndrew::construct_hull_c_all(double *data0, int ndata0)
{
    vector<Point> result;

    Point c;

    for(int i = 0; i < ndata0/2; i++)
    {
        c.x = data0[i*2+0];
        c.y = data0[i*2+1];
        result.push_back(c);
    }

    /*NL*/ //if (screen) fprintf(screen,"ndata0 %d result.size() %d\n",ndata0,result.size());

    return result;
}

/* ---------------------------------------------------------------------- */

// area of triangle spanned by three points p,m,q
// based on cross product
double ModifiedAndrew::area(Point &p, Point &m, Point &q){
return 0.5*(-(m.y*p.x) + m.x*p.y +
      m.y*q.x - p.y*q.x - m.x*q.y + p.x*q.y);
}

/* ---------------------------------------------------------------------- */

// area of convex hull
double ModifiedAndrew::area(vector<Point> H){
  double a = 0.0;
  Point m = mean_point(H);

  for (size_t i = 1; i < H.size(); i++){
    a += area(H[i-1],m,H[i]);
  }

  return a;
}

/* ---------------------------------------------------------------------- */

// 2D cross product of OA and OB vectors, i.e. z-component of their 3D cross product.
// Returns a positive value, if OAB makes a counter-clockwise turn,
// negative for clockwise turn, and zero if the points are collinear.
double ModifiedAndrew::cross(Point O, Point A, Point B)
{
  return (A.x - O.x)*(B.y - O.y) - (A.y - O.y)*(B.x - O.x);
}


/* ---------------------------------------------------------------------- */

// find the mean of a vector of points (excluding the first)
Point ModifiedAndrew::mean_point(vector<Point> P){
  Point mean;

  double x_accum = 0.0, y_accum = 0.0;

  for (size_t i = 1; i < P.size(); i++){
    x_accum += P[i].x;
    y_accum += P[i].y;
  }

  mean.x = x_accum/(static_cast<double>(P.size())-1.);
  mean.y = y_accum/(static_cast<double>(P.size())-1.);

  return mean;
}

/* ---------------------------------------------------------------------- */

// Returns a list of points on the convex hull in counter-clockwise order.
// Note: the last circle in the returned list is the same as the first one.
vector<Point> ModifiedAndrew::convex_hull(vector<Point> P)
{
    int n = P.size(), k = 0;
    vector<Point> H(2*n);

    // Sort points lexicographically
    sort(P.begin(), P.end());

    // Build lower hull
    for (int i = 0; i < n; i++) {
        while (k >= 2 && cross(H[k-2], H[k-1], P[i]) <= 0) k--;
        H[k++] = P[i];
    }

    // Build upper hull
    for (int i = n-2, t = k+1; i >= 0; i--) {
        while (k >= t && cross(H[k-2], H[k-1], P[i]) <= 0) k--;
        H[k++] = P[i];
    }

    H.resize(k);
    return H;
}