solid.h

/* -*- c++ -*- ----------------------------------------------------------
 *
 *                    ***       Karamelo       ***
 *               Parallel Material Point Method Simulator
 * 
 * Copyright (2019) Alban de Vaucorbeil, alban.devaucorbeil@monash.edu
 * Materials Science and Engineering, Monash University
 * Clayton VIC 3800, Australia

 * This software is distributed under the GNU General Public License.
 *
 * ----------------------------------------------------------------------- */

#ifndef MPM_SOLID_H
#define MPM_SOLID_H

#include "pointers.h"
#include "material.h"
#include "grid.h"
#include <vector>
#include <Eigen/Eigen>


using namespace Eigen;

class Solid : protected Pointers {
 public:
  string id;                                
  bigint np;                                
  int np_local;                             
  int comm_n;                               
  double vtot;                              
  double mtot;                              

  vector<tagint> ptag;                      

  double solidlo[3], solidhi[3];            
  double solidsublo[3], solidsubhi[3];      

  vector<Eigen::Vector3d> x;                
  vector<Eigen::Vector3d> x0;               

  
  vector<Eigen::Vector3d> rp;               
  vector<Eigen::Vector3d> rp0;              
  vector<Eigen::Vector3d> xpc;              
  vector<Eigen::Vector3d> xpc0;             
  int nc;                                   
  
  vector<Eigen::Vector3d> v;                
  vector<Eigen::Vector3d> v_update;         

  vector<Eigen::Vector3d> a;                

  vector<Eigen::Vector3d> mbp;              
  vector<Eigen::Vector3d> f;                

  vector<Eigen::Matrix3d> sigma;            
  vector<Eigen::Matrix3d> strain_el;        
  vector<Eigen::Matrix3d> vol0PK1;          
  vector<Eigen::Matrix3d> L;                
  vector<Eigen::Matrix3d> F;                
  vector<Eigen::Matrix3d> R;                
  vector<Eigen::Matrix3d> D;                
  vector<Eigen::Matrix3d> Finv;             
  vector<Eigen::Matrix3d> Fdot;             
  vector<Eigen::Matrix3d> Di;               

  vector<double> J;                         
  vector<double> vol0;                      
  vector<double> vol;                       
  vector<double> rho0;                      
  vector<double> rho;                       
  vector<double> mass;                      
  vector<double> eff_plastic_strain;        
  vector<double> eff_plastic_strain_rate;   
  vector<double> damage;                    
  vector<double> damage_init;               
  vector<double> T;                         
  vector<double> ienergy;                   
  vector<double> pH_regu;                   
  vector<int> mask;                         
  vector<bool> check;

  double max_p_wave_speed;                  
  double dtCFL;
  
  vector<int> numneigh_pn;                  
  vector<int> numneigh_np;                  
  vector<vector<int>> neigh_pn;             
  vector<vector<int>> neigh_np;             

  vector<vector< double >> wf_pn;           
  vector<vector< double >> wf_np;           
  vector<vector< double >> wf_pn_corners;   

  vector<vector< Eigen::Vector3d >> wfd_pn; 
  vector<vector< Eigen::Vector3d >> wfd_np; 


  struct Mat *mat;                          

  class Grid *grid;                         

  string method_type;                       

  Solid(class MPM *, vector<string>);       
  virtual ~Solid();

  void init();                              
  void options(vector<string> *, vector<string>::iterator); 
  void grow(int);                           

  void compute_mass_nodes(bool);                    
  void compute_velocity_nodes(bool);                
  void compute_velocity_nodes_APIC(bool);           
  void compute_external_forces_nodes(bool);         
  void compute_internal_forces_nodes_TL();          
  void compute_internal_forces_nodes_UL(bool);      
  void compute_particle_velocities_and_positions(); 
  void compute_particle_acceleration();             
  void update_particle_velocities(double);          
  void compute_rate_deformation_gradient_TL();      
  void compute_rate_deformation_gradient_TL_APIC(); 
  void compute_rate_deformation_gradient_UL_USL();  
  void compute_rate_deformation_gradient_UL_MUSL(); 
  void compute_rate_deformation_gradient_UL_APIC(); 
  void update_deformation_gradient();               
  void update_stress();                             
  void compute_inertia_tensor(string);              
  void compute_deformation_gradient();              
  void update_particle_domain();                    

  void copy_particle(int, int);                     
  void pack_particle(int, vector<double> &);        
  void unpack_particle(int &, vector<int>, double[]); 

private:
  void populate(vector<string>);
  void read_mesh(string);
  void read_file(string);

  const map<string, string> usage ={
    {"region", "Usage: solid(solid-ID, \033[1;32mregion\033[0m, region-ID, N_ppc1D, material-ID, cell-size, T0)\n"},
    {"mesh",    "Usage: solid(solid-ID, \033[1;32mmesh\033[0m, meshfile, material-ID, h, T0)\n"},
    {"file",    "Usage: solid(solid-ID, \033[1;32mfile\033[0m, filename, material-ID, h, T0)\n"}
  };
  const map<string, int>    Nargs = {
             {"region", 7},
             {"mesh",   6},
             {"file",   6}
           };
  
  double T0;                     
  bool is_TL, apic;              
};

#endif