Merge branch 'write-bonus-data' of github.com:lammps/lammps into write-bonus-data

src/BODY/body_rounded_polygon.cpp

@@ -225,7 +225,7 @@ void BodyRoundedPolygon::data_body(int ibonus, int ninteger, int ndouble,
   ez_space[0] = evectors[0][2];
   ez_space[1] = evectors[1][2];
   ez_space[2] = evectors[2][2];
-  
+
   // enforce 3 evectors as a right-handed coordinate system
   // flip 3rd vector if needed
 
@@ -243,11 +243,11 @@ void BodyRoundedPolygon::data_body(int ibonus, int ninteger, int ndouble,
   int i,m;
   double rsq,erad,rrad;
   double delta[3];
-    
+
   double erad2 = 0.0;
   int j = 6;
   int k = 0;
-  
+
   for (i = 0; i < nsub; i++) {
     delta[0] = dfile[j];
     delta[1] = dfile[j+1];
@@ -264,9 +264,9 @@ void BodyRoundedPolygon::data_body(int ibonus, int ninteger, int ndouble,
   // the next 2 or 2*nsub elements are edge ends
   // the final two values are the enclosing radius and rounded radius
   // set atom->radius = enclosing + rounded radii (except for spheres)
-  
+
   // spheres have just 1 edge
-  
+
   if (nsub == 1) {
     bonus->dvalue[k] = 0;
     bonus->dvalue[k+1] = 0;
@@ -282,7 +282,7 @@ void BodyRoundedPolygon::data_body(int ibonus, int ninteger, int ndouble,
     atom->radius[bonus->ilocal] = erad;
 
   // rods have just 1 edge
-    
+
   } else if (nsub == 2) {
     bonus->dvalue[k] = 0;
     bonus->dvalue[k+1] = 1;
@@ -298,7 +298,7 @@ void BodyRoundedPolygon::data_body(int ibonus, int ninteger, int ndouble,
     atom->radius[bonus->ilocal] = erad + rrad;
 
   // polygons have Nsub edges
-    
+
   } else {
     for (i = 0; i < nsub; i++) {
       bonus->dvalue[k] = i;
@@ -380,7 +380,7 @@ int BodyRoundedPolygon::pack_data_body(tagint atomID, int ibonus, double *buf)
     if (nsub < 3) ilast = 3*nsub + 2 + 1;
     else ilast = 3*nsub + 2*nsub + 1;
     buf[m++] = 2.0 * dvalue[ilast];
-    
+
   } else m = 3 + 1 + 6 + 3*nsub + 1;
 
   return m;
@@ -409,12 +409,12 @@ int BodyRoundedPolygon::write_data_body(FILE *fp, double *buf)
   m += 6;
 
   // nsub vertices
-  
+
   for (int i = 0; i < nsub; i++, m+=3)
     fmt::print(fp,"{} {} {}\n",buf[m],buf[m+1],buf[m+2]);
 
   // rounded diameter
-  
+
   double diameter = buf[m++];
   fmt::print(fp,"{}\n",diameter);
 

unittest/formats/test_atom_styles.cpp

@@ -2119,6 +2119,7 @@ TEST_F(AtomStyleTest, bond)
 
     if (!verbose) ::testing::internal::CaptureStdout();
     lmp->input->one("atom_style bond");
+    lmp->input->one("newton on");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("bond"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -2360,6 +2361,66 @@ TEST_F(AtomStyleTest, bond)
     lmp->input->one("write_data test_atom_styles.data nocoeff");
     lmp->input->one("clear");
     lmp->input->one("units real");
+    lmp->input->one("newton off");
+    lmp->input->one("atom_style bond");
+    lmp->input->one("pair_style zero 4.0");
+    lmp->input->one("bond_style zero");
+    lmp->input->one("atom_modify map array");
+    lmp->input->one("read_data test_atom_styles.data");
+    lmp->input->one("pair_coeff * *");
+    lmp->input->one("bond_coeff * 4.0");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("bond"));
+    ASSERT_NE(lmp->atom->avec, nullptr);
+
+    ASSERT_EQ(lmp->atom->natoms, 6);
+    ASSERT_EQ(lmp->atom->nlocal, 6);
+    ASSERT_EQ(lmp->atom->nbonds, 5);
+    ASSERT_EQ(lmp->atom->nghost, 0);
+    ASSERT_NE(lmp->atom->nmax, -1);
+    ASSERT_EQ(lmp->atom->tag_enable, 1);
+    ASSERT_EQ(lmp->atom->molecular, 1);
+    ASSERT_EQ(lmp->atom->ntypes, 3);
+    ASSERT_NE(lmp->atom->sametag, nullptr);
+    ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
+    ASSERT_EQ(lmp->atom->map_style, 1);
+    ASSERT_EQ(lmp->atom->map_user, 1);
+    ASSERT_EQ(lmp->atom->map_tag_max, 6);
+
+    auto num_bond  = lmp->atom->num_bond;
+    auto bond_type = lmp->atom->bond_type;
+    auto bond_atom = lmp->atom->bond_atom;
+
+    ASSERT_EQ(num_bond[GETIDX(1)], 2);
+    ASSERT_EQ(num_bond[GETIDX(2)], 0);
+    ASSERT_EQ(num_bond[GETIDX(3)], 3);
+    ASSERT_EQ(num_bond[GETIDX(4)], 0);
+    ASSERT_EQ(num_bond[GETIDX(5)], 3);
+    ASSERT_EQ(num_bond[GETIDX(6)], 2);
+    ASSERT_EQ(bond_type[GETIDX(1)][0], 1);
+    ASSERT_EQ(bond_type[GETIDX(1)][1], 1);
+    ASSERT_EQ(bond_type[GETIDX(3)][0], 1);
+    ASSERT_EQ(bond_type[GETIDX(3)][1], 2);
+    ASSERT_EQ(bond_type[GETIDX(3)][2], 2);
+    ASSERT_EQ(bond_type[GETIDX(5)][0], 1);
+    ASSERT_EQ(bond_type[GETIDX(5)][1], 2);
+    ASSERT_EQ(bond_type[GETIDX(5)][2], 2);
+    ASSERT_EQ(bond_type[GETIDX(6)][0], 2);
+    ASSERT_EQ(bond_type[GETIDX(6)][1], 2);
+    ASSERT_EQ(bond_atom[GETIDX(1)][0], 5);
+    ASSERT_EQ(bond_atom[GETIDX(1)][1], 3);
+    ASSERT_EQ(bond_atom[GETIDX(3)][0], 1);
+    ASSERT_EQ(bond_atom[GETIDX(3)][1], 5);
+    ASSERT_EQ(bond_atom[GETIDX(3)][2], 6);
+    ASSERT_EQ(bond_atom[GETIDX(5)][0], 1);
+    ASSERT_EQ(bond_atom[GETIDX(5)][1], 3);
+    ASSERT_EQ(bond_atom[GETIDX(5)][2], 6);
+    ASSERT_EQ(bond_atom[GETIDX(6)][0], 3);
+    ASSERT_EQ(bond_atom[GETIDX(6)][1], 5);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    lmp->input->one("clear");
+    lmp->input->one("units real");
     lmp->input->one("atom_style bond");
     lmp->input->one("pair_style zero 4.0");
     lmp->input->one("bond_style zero");
@@ -2388,8 +2449,8 @@ TEST_F(AtomStyleTest, bond)
     auto x         = lmp->atom->x;
     auto v         = lmp->atom->v;
     auto type      = lmp->atom->type;
-    auto num_bond  = lmp->atom->num_bond;
-    auto bond_atom = lmp->atom->bond_atom;
+    num_bond  = lmp->atom->num_bond;
+    bond_atom = lmp->atom->bond_atom;
 
     ASSERT_DOUBLE_EQ(x[GETIDX(1)][0], -2.0);
     ASSERT_DOUBLE_EQ(x[GETIDX(1)][1], 2.0);
@@ -2493,6 +2554,484 @@ TEST_F(AtomStyleTest, bond)
     ASSERT_EQ(type[GETIDX(8)], 3);
 }
 
+TEST_F(AtomStyleTest, angle)
+{
+    if (!LAMMPS::is_installed_pkg("MOLECULE")) GTEST_SKIP();
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    lmp->input->one("atom_style angle");
+    lmp->input->one("newton on");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("angle"));
+    ASSERT_NE(lmp->atom->avec, nullptr);
+    ASSERT_EQ(lmp->atom->natoms, 0);
+    ASSERT_EQ(lmp->atom->nlocal, 0);
+    ASSERT_EQ(lmp->atom->nghost, 0);
+    ASSERT_EQ(lmp->atom->nmax, 1);
+    ASSERT_EQ(lmp->atom->tag_enable, 1);
+    ASSERT_EQ(lmp->atom->molecular, 1);
+    ASSERT_EQ(lmp->atom->nellipsoids, 0);
+    ASSERT_EQ(lmp->atom->nlines, 0);
+    ASSERT_EQ(lmp->atom->ntris, 0);
+    ASSERT_EQ(lmp->atom->nbodies, 0);
+    ASSERT_EQ(lmp->atom->nbonds, 0);
+    ASSERT_EQ(lmp->atom->nangles, 0);
+    ASSERT_EQ(lmp->atom->ndihedrals, 0);
+    ASSERT_EQ(lmp->atom->nimpropers, 0);
+    ASSERT_EQ(lmp->atom->ntypes, 0);
+    ASSERT_EQ(lmp->atom->nbondtypes, 0);
+    ASSERT_EQ(lmp->atom->nangletypes, 0);
+    ASSERT_EQ(lmp->atom->ndihedraltypes, 0);
+    ASSERT_EQ(lmp->atom->nimpropertypes, 0);
+    ASSERT_EQ(lmp->atom->bond_per_atom, 0);
+    ASSERT_EQ(lmp->atom->angle_per_atom, 0);
+    ASSERT_EQ(lmp->atom->dihedral_per_atom, 0);
+    ASSERT_EQ(lmp->atom->improper_per_atom, 0);
+    ASSERT_EQ(lmp->atom->extra_bond_per_atom, 0);
+    ASSERT_EQ(lmp->atom->extra_angle_per_atom, 0);
+    ASSERT_EQ(lmp->atom->extra_dihedral_per_atom, 0);
+    ASSERT_EQ(lmp->atom->extra_improper_per_atom, 0);
+
+    ASSERT_EQ(lmp->atom->sphere_flag, 0);
+    ASSERT_EQ(lmp->atom->ellipsoid_flag, 0);
+    ASSERT_EQ(lmp->atom->line_flag, 0);
+    ASSERT_EQ(lmp->atom->tri_flag, 0);
+    ASSERT_EQ(lmp->atom->body_flag, 0);
+    ASSERT_EQ(lmp->atom->peri_flag, 0);
+    ASSERT_EQ(lmp->atom->electron_flag, 0);
+    ASSERT_EQ(lmp->atom->wavepacket_flag, 0);
+    ASSERT_EQ(lmp->atom->sph_flag, 0);
+    ASSERT_EQ(lmp->atom->molecule_flag, 1);
+    ASSERT_EQ(lmp->atom->molindex_flag, 0);
+    ASSERT_EQ(lmp->atom->molatom_flag, 0);
+    ASSERT_EQ(lmp->atom->q_flag, 0);
+    ASSERT_EQ(lmp->atom->mu_flag, 0);
+    ASSERT_EQ(lmp->atom->rmass_flag, 0);
+    ASSERT_EQ(lmp->atom->radius_flag, 0);
+    ASSERT_EQ(lmp->atom->omega_flag, 0);
+    ASSERT_EQ(lmp->atom->torque_flag, 0);
+    ASSERT_EQ(lmp->atom->angmom_flag, 0);
+    ASSERT_EQ(lmp->atom->vfrac_flag, 0);
+    ASSERT_EQ(lmp->atom->spin_flag, 0);
+    ASSERT_EQ(lmp->atom->eradius_flag, 0);
+    ASSERT_EQ(lmp->atom->ervel_flag, 0);
+    ASSERT_EQ(lmp->atom->erforce_flag, 0);
+    ASSERT_EQ(lmp->atom->cs_flag, 0);
+    ASSERT_EQ(lmp->atom->csforce_flag, 0);
+    ASSERT_EQ(lmp->atom->vforce_flag, 0);
+    ASSERT_EQ(lmp->atom->ervelforce_flag, 0);
+    ASSERT_EQ(lmp->atom->etag_flag, 0);
+    ASSERT_EQ(lmp->atom->rho_flag, 0);
+    ASSERT_EQ(lmp->atom->esph_flag, 0);
+    ASSERT_EQ(lmp->atom->cv_flag, 0);
+    ASSERT_EQ(lmp->atom->vest_flag, 0);
+    ASSERT_EQ(lmp->atom->dpd_flag, 0);
+    ASSERT_EQ(lmp->atom->edpd_flag, 0);
+    ASSERT_EQ(lmp->atom->tdpd_flag, 0);
+    ASSERT_EQ(lmp->atom->mesont_flag, 0);
+    ASSERT_EQ(lmp->atom->sp_flag, 0);
+    ASSERT_EQ(lmp->atom->x0_flag, 0);
+    ASSERT_EQ(lmp->atom->smd_flag, 0);
+    ASSERT_EQ(lmp->atom->damage_flag, 0);
+    ASSERT_EQ(lmp->atom->contact_radius_flag, 0);
+    ASSERT_EQ(lmp->atom->smd_data_9_flag, 0);
+    ASSERT_EQ(lmp->atom->smd_stress_flag, 0);
+    ASSERT_EQ(lmp->atom->eff_plastic_strain_flag, 0);
+    ASSERT_EQ(lmp->atom->eff_plastic_strain_rate_flag, 0);
+    ASSERT_EQ(lmp->atom->pdscale, 1.0);
+
+    ASSERT_NE(lmp->atom->tag, nullptr);
+    ASSERT_NE(lmp->atom->type, nullptr);
+    ASSERT_NE(lmp->atom->mask, nullptr);
+    ASSERT_NE(lmp->atom->image, nullptr);
+    ASSERT_NE(lmp->atom->x, nullptr);
+    ASSERT_NE(lmp->atom->v, nullptr);
+    ASSERT_NE(lmp->atom->f, nullptr);
+    ASSERT_EQ(lmp->atom->q, nullptr);
+    ASSERT_EQ(lmp->atom->mu, nullptr);
+    ASSERT_EQ(lmp->atom->omega, nullptr);
+    ASSERT_EQ(lmp->atom->angmom, nullptr);
+    ASSERT_EQ(lmp->atom->torque, nullptr);
+    ASSERT_EQ(lmp->atom->radius, nullptr);
+    ASSERT_EQ(lmp->atom->rmass, nullptr);
+    ASSERT_EQ(lmp->atom->ellipsoid, nullptr);
+    ASSERT_EQ(lmp->atom->line, nullptr);
+    ASSERT_EQ(lmp->atom->tri, nullptr);
+    ASSERT_EQ(lmp->atom->body, nullptr);
+    ASSERT_NE(lmp->atom->molecule, nullptr);
+    ASSERT_EQ(lmp->atom->molindex, nullptr);
+    ASSERT_EQ(lmp->atom->molatom, nullptr);
+    ASSERT_NE(lmp->atom->num_bond, nullptr);
+    ASSERT_NE(lmp->atom->bond_type, nullptr);
+    ASSERT_NE(lmp->atom->bond_atom, nullptr);
+    ASSERT_NE(lmp->atom->num_angle, nullptr);
+    ASSERT_NE(lmp->atom->angle_type, nullptr);
+    ASSERT_NE(lmp->atom->angle_atom1, nullptr);
+    ASSERT_NE(lmp->atom->angle_atom2, nullptr);
+    ASSERT_NE(lmp->atom->angle_atom3, nullptr);
+    ASSERT_EQ(lmp->atom->num_dihedral, nullptr);
+    ASSERT_EQ(lmp->atom->dihedral_type, nullptr);
+    ASSERT_EQ(lmp->atom->dihedral_atom1, nullptr);
+    ASSERT_EQ(lmp->atom->dihedral_atom2, nullptr);
+    ASSERT_EQ(lmp->atom->dihedral_atom3, nullptr);
+    ASSERT_EQ(lmp->atom->dihedral_atom4, nullptr);
+    ASSERT_EQ(lmp->atom->num_improper, nullptr);
+    ASSERT_EQ(lmp->atom->improper_type, nullptr);
+    ASSERT_EQ(lmp->atom->improper_atom1, nullptr);
+    ASSERT_EQ(lmp->atom->improper_atom2, nullptr);
+    ASSERT_EQ(lmp->atom->improper_atom3, nullptr);
+    ASSERT_EQ(lmp->atom->improper_atom4, nullptr);
+    ASSERT_EQ(lmp->atom->maxspecial, 1);
+    ASSERT_NE(lmp->atom->nspecial, nullptr);
+    ASSERT_NE(lmp->atom->special, nullptr);
+    ASSERT_EQ(lmp->atom->vfrac, nullptr);
+    ASSERT_EQ(lmp->atom->s0, nullptr);
+    ASSERT_EQ(lmp->atom->x0, nullptr);
+    ASSERT_EQ(lmp->atom->sp, nullptr);
+    ASSERT_EQ(lmp->atom->fm, nullptr);
+    ASSERT_EQ(lmp->atom->fm_long, nullptr);
+    ASSERT_EQ(lmp->atom->spin, nullptr);
+    ASSERT_EQ(lmp->atom->eradius, nullptr);
+    ASSERT_EQ(lmp->atom->ervel, nullptr);
+    ASSERT_EQ(lmp->atom->erforce, nullptr);
+    ASSERT_EQ(lmp->atom->ervelforce, nullptr);
+    ASSERT_EQ(lmp->atom->cs, nullptr);
+    ASSERT_EQ(lmp->atom->csforce, nullptr);
+    ASSERT_EQ(lmp->atom->vforce, nullptr);
+    ASSERT_EQ(lmp->atom->etag, nullptr);
+    ASSERT_EQ(lmp->atom->uCond, nullptr);
+    ASSERT_EQ(lmp->atom->uMech, nullptr);
+    ASSERT_EQ(lmp->atom->uChem, nullptr);
+    ASSERT_EQ(lmp->atom->uCG, nullptr);
+    ASSERT_EQ(lmp->atom->uCGnew, nullptr);
+    ASSERT_EQ(lmp->atom->duChem, nullptr);
+    ASSERT_EQ(lmp->atom->dpdTheta, nullptr);
+    ASSERT_EQ(lmp->atom->cc, nullptr);
+    ASSERT_EQ(lmp->atom->cc_flux, nullptr);
+    ASSERT_EQ(lmp->atom->edpd_temp, nullptr);
+    ASSERT_EQ(lmp->atom->edpd_flux, nullptr);
+    ASSERT_EQ(lmp->atom->edpd_cv, nullptr);
+    ASSERT_EQ(lmp->atom->length, nullptr);
+    ASSERT_EQ(lmp->atom->buckling, nullptr);
+    ASSERT_EQ(lmp->atom->bond_nt, nullptr);
+    ASSERT_EQ(lmp->atom->contact_radius, nullptr);
+    ASSERT_EQ(lmp->atom->smd_data_9, nullptr);
+    ASSERT_EQ(lmp->atom->smd_stress, nullptr);
+    ASSERT_EQ(lmp->atom->eff_plastic_strain, nullptr);
+    ASSERT_EQ(lmp->atom->eff_plastic_strain_rate, nullptr);
+    ASSERT_EQ(lmp->atom->damage, nullptr);
+    ASSERT_EQ(lmp->atom->rho, nullptr);
+    ASSERT_EQ(lmp->atom->drho, nullptr);
+    ASSERT_EQ(lmp->atom->esph, nullptr);
+    ASSERT_EQ(lmp->atom->desph, nullptr);
+    ASSERT_EQ(lmp->atom->cv, nullptr);
+    ASSERT_EQ(lmp->atom->vest, nullptr);
+    ASSERT_EQ(lmp->atom->nmolecule, 0);
+    ASSERT_EQ(lmp->atom->molecules, nullptr);
+    ASSERT_EQ(lmp->atom->nivector, 0);
+    ASSERT_EQ(lmp->atom->ndvector, 0);
+    ASSERT_EQ(lmp->atom->iname, nullptr);
+    ASSERT_EQ(lmp->atom->dname, nullptr);
+    ASSERT_EQ(lmp->atom->mass, nullptr);
+    ASSERT_EQ(lmp->atom->mass_setflag, nullptr);
+    ASSERT_EQ(lmp->atom->nextra_grow, 0);
+    ASSERT_EQ(lmp->atom->nextra_restart, 0);
+    ASSERT_EQ(lmp->atom->nextra_border, 0);
+    ASSERT_EQ(lmp->atom->nextra_grow_max, 0);
+    ASSERT_EQ(lmp->atom->nextra_restart_max, 0);
+    ASSERT_EQ(lmp->atom->nextra_border_max, 0);
+    ASSERT_EQ(lmp->atom->nextra_store, 0);
+    ASSERT_EQ(lmp->atom->extra_grow, nullptr);
+    ASSERT_EQ(lmp->atom->extra_restart, nullptr);
+    ASSERT_EQ(lmp->atom->extra_border, nullptr);
+    ASSERT_EQ(lmp->atom->extra, nullptr);
+    ASSERT_EQ(lmp->atom->sametag, nullptr);
+    ASSERT_EQ(lmp->atom->map_style, 3);
+    ASSERT_EQ(lmp->atom->map_user, 0);
+    ASSERT_EQ(lmp->atom->map_tag_max, -1);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    lmp->input->one("create_box 3 box bond/types 2 angle/types 1 "
+                    "extra/bond/per/atom 2 extra/angle/per/atom 1 "
+                    "extra/special/per/atom 4");
+    lmp->input->one("create_atoms 1 single -2.0  2.0  0.1");
+    lmp->input->one("create_atoms 1 single -2.0 -2.0 -0.1");
+    lmp->input->one("create_atoms 2 single  2.0  2.0 -0.1");
+    lmp->input->one("create_atoms 2 single  2.0 -2.0  0.1");
+    lmp->input->one("create_atoms 3 single  2.0  2.0 -2.1");
+    lmp->input->one("create_atoms 3 single  2.0 -2.0  2.1");
+    lmp->input->one("mass 1 4.0");
+    lmp->input->one("mass 2 2.4");
+    lmp->input->one("mass 3 4.4");
+    lmp->input->one("pair_coeff * *");
+    lmp->input->one("bond_style zero");
+    lmp->input->one("bond_coeff * 4.0");
+    lmp->input->one("angle_style zero");
+    lmp->input->one("angle_coeff * 90.0");
+    lmp->input->one("create_bonds single/bond 1 1 3");
+    lmp->input->one("create_bonds single/bond 1 1 5");
+    lmp->input->one("create_bonds single/bond 2 3 5");
+    lmp->input->one("create_bonds single/bond 2 3 6");
+    lmp->input->one("create_bonds single/bond 2 5 6");
+    lmp->input->one("create_bonds single/angle 1 1 3 5");
+    lmp->input->one("create_bonds single/angle 1 3 5 6");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("angle"));
+    ASSERT_NE(lmp->atom->avec, nullptr);
+    ASSERT_EQ(lmp->atom->natoms, 6);
+    ASSERT_EQ(lmp->atom->nbonds, 5);
+    ASSERT_EQ(lmp->atom->nbondtypes, 2);
+    ASSERT_EQ(lmp->atom->nangles, 2);
+    ASSERT_EQ(lmp->atom->nangletypes, 1);
+    ASSERT_EQ(lmp->atom->nellipsoids, 0);
+    ASSERT_EQ(lmp->atom->nlocal, 6);
+    ASSERT_EQ(lmp->atom->nghost, 0);
+    ASSERT_NE(lmp->atom->nmax, -1);
+    ASSERT_EQ(lmp->atom->tag_enable, 1);
+    ASSERT_EQ(lmp->atom->molecular, 1);
+    ASSERT_EQ(lmp->atom->ntypes, 3);
+    ASSERT_EQ(lmp->atom->nextra_grow, 0);
+    ASSERT_EQ(lmp->atom->nextra_restart, 0);
+    ASSERT_EQ(lmp->atom->nextra_border, 0);
+    ASSERT_EQ(lmp->atom->nextra_grow_max, 0);
+    ASSERT_EQ(lmp->atom->nextra_restart_max, 0);
+    ASSERT_EQ(lmp->atom->nextra_border_max, 0);
+    ASSERT_EQ(lmp->atom->nextra_store, 0);
+    ASSERT_EQ(lmp->atom->extra_grow, nullptr);
+    ASSERT_EQ(lmp->atom->extra_restart, nullptr);
+    ASSERT_EQ(lmp->atom->extra_border, nullptr);
+    ASSERT_EQ(lmp->atom->extra, nullptr);
+
+    ASSERT_NE(lmp->atom->mass, nullptr);
+    ASSERT_NE(lmp->atom->mass_setflag, nullptr);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    lmp->input->one("write_data test_atom_styles.data nocoeff");
+    lmp->input->one("clear");
+    lmp->input->one("units real");
+    lmp->input->one("newton off");
+    lmp->input->one("atom_style angle");
+    lmp->input->one("pair_style zero 4.0");
+    lmp->input->one("bond_style zero");
+    lmp->input->one("angle_style zero");
+    lmp->input->one("atom_modify map array");
+    lmp->input->one("read_data test_atom_styles.data");
+    lmp->input->one("pair_coeff * *");
+    lmp->input->one("bond_coeff * 4.0");
+    lmp->input->one("angle_coeff * 90.0");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("angle"));
+    ASSERT_NE(lmp->atom->avec, nullptr);
+
+    ASSERT_EQ(lmp->atom->natoms, 6);
+    ASSERT_EQ(lmp->atom->nlocal, 6);
+    ASSERT_EQ(lmp->atom->nbonds, 5);
+    ASSERT_EQ(lmp->atom->nghost, 0);
+    ASSERT_NE(lmp->atom->nmax, -1);
+    ASSERT_EQ(lmp->atom->tag_enable, 1);
+    ASSERT_EQ(lmp->atom->molecular, 1);
+    ASSERT_EQ(lmp->atom->ntypes, 3);
+    ASSERT_NE(lmp->atom->sametag, nullptr);
+    ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
+    ASSERT_EQ(lmp->atom->map_style, 1);
+    ASSERT_EQ(lmp->atom->map_user, 1);
+    ASSERT_EQ(lmp->atom->map_tag_max, 6);
+
+    auto num_bond  = lmp->atom->num_bond;
+    auto bond_type = lmp->atom->bond_type;
+    auto bond_atom = lmp->atom->bond_atom;
+    auto num_angle  = lmp->atom->num_angle;
+    auto angle_atom1 = lmp->atom->angle_atom1;
+    auto angle_atom2 = lmp->atom->angle_atom2;
+    auto angle_atom3 = lmp->atom->angle_atom3;
+
+    ASSERT_EQ(num_bond[GETIDX(1)], 2);
+    ASSERT_EQ(num_bond[GETIDX(2)], 0);
+    ASSERT_EQ(num_bond[GETIDX(3)], 3);
+    ASSERT_EQ(num_bond[GETIDX(4)], 0);
+    ASSERT_EQ(num_bond[GETIDX(5)], 3);
+    ASSERT_EQ(num_bond[GETIDX(6)], 2);
+    ASSERT_EQ(bond_type[GETIDX(1)][0], 1);
+    ASSERT_EQ(bond_type[GETIDX(1)][1], 1);
+    ASSERT_EQ(bond_type[GETIDX(3)][0], 1);
+    ASSERT_EQ(bond_type[GETIDX(3)][1], 2);
+    ASSERT_EQ(bond_type[GETIDX(3)][2], 2);
+    ASSERT_EQ(bond_type[GETIDX(5)][0], 1);
+    ASSERT_EQ(bond_type[GETIDX(5)][1], 2);
+    ASSERT_EQ(bond_type[GETIDX(5)][2], 2);
+    ASSERT_EQ(bond_type[GETIDX(6)][0], 2);
+    ASSERT_EQ(bond_type[GETIDX(6)][1], 2);
+    ASSERT_EQ(bond_atom[GETIDX(1)][0], 3);
+    ASSERT_EQ(bond_atom[GETIDX(1)][1], 5);
+    ASSERT_EQ(bond_atom[GETIDX(3)][0], 1);
+    ASSERT_EQ(bond_atom[GETIDX(3)][1], 5);
+    ASSERT_EQ(bond_atom[GETIDX(3)][2], 6);
+    ASSERT_EQ(bond_atom[GETIDX(5)][0], 1);
+    ASSERT_EQ(bond_atom[GETIDX(5)][1], 3);
+    ASSERT_EQ(bond_atom[GETIDX(5)][2], 6);
+    ASSERT_EQ(bond_atom[GETIDX(6)][0], 3);
+    ASSERT_EQ(bond_atom[GETIDX(6)][1], 5);
+    ASSERT_EQ(num_angle[GETIDX(1)], 1);
+    ASSERT_EQ(num_angle[GETIDX(2)], 0);
+    ASSERT_EQ(num_angle[GETIDX(3)], 2);
+    ASSERT_EQ(num_angle[GETIDX(4)], 0);
+    ASSERT_EQ(num_angle[GETIDX(5)], 2);
+    ASSERT_EQ(num_angle[GETIDX(6)], 1);
+    ASSERT_EQ(angle_atom1[GETIDX(1)][0], 1);
+    ASSERT_EQ(angle_atom2[GETIDX(1)][0], 3);
+    ASSERT_EQ(angle_atom3[GETIDX(1)][0], 5);
+    ASSERT_EQ(angle_atom1[GETIDX(3)][0], 1);
+    ASSERT_EQ(angle_atom2[GETIDX(3)][0], 3);
+    ASSERT_EQ(angle_atom3[GETIDX(3)][0], 5);
+    ASSERT_EQ(angle_atom1[GETIDX(3)][1], 3);
+    ASSERT_EQ(angle_atom2[GETIDX(3)][1], 5);
+    ASSERT_EQ(angle_atom3[GETIDX(3)][1], 6);
+    ASSERT_EQ(angle_atom1[GETIDX(5)][0], 1);
+    ASSERT_EQ(angle_atom2[GETIDX(5)][0], 3);
+    ASSERT_EQ(angle_atom3[GETIDX(5)][0], 5);
+    ASSERT_EQ(angle_atom1[GETIDX(5)][1], 3);
+    ASSERT_EQ(angle_atom2[GETIDX(5)][1], 5);
+    ASSERT_EQ(angle_atom3[GETIDX(5)][1], 6);
+    ASSERT_EQ(angle_atom1[GETIDX(6)][0], 3);
+    ASSERT_EQ(angle_atom2[GETIDX(6)][0], 5);
+    ASSERT_EQ(angle_atom3[GETIDX(6)][0], 6);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    lmp->input->one("clear");
+    lmp->input->one("units real");
+    lmp->input->one("atom_style angle");
+    lmp->input->one("pair_style zero 4.0");
+    lmp->input->one("bond_style zero");
+    lmp->input->one("atom_modify map array");
+    lmp->input->one("read_data test_atom_styles.data");
+    lmp->input->one("pair_coeff * *");
+    lmp->input->one("bond_coeff * 4.0");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("angle"));
+    ASSERT_NE(lmp->atom->avec, nullptr);
+
+    ASSERT_EQ(lmp->atom->natoms, 6);
+    ASSERT_EQ(lmp->atom->nlocal, 6);
+    ASSERT_EQ(lmp->atom->nbonds, 5);
+    ASSERT_EQ(lmp->atom->nghost, 0);
+    ASSERT_NE(lmp->atom->nmax, -1);
+    ASSERT_EQ(lmp->atom->tag_enable, 1);
+    ASSERT_EQ(lmp->atom->molecular, 1);
+    ASSERT_EQ(lmp->atom->ntypes, 3);
+    ASSERT_NE(lmp->atom->sametag, nullptr);
+    ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
+    ASSERT_EQ(lmp->atom->map_style, 1);
+    ASSERT_EQ(lmp->atom->map_user, 1);
+    ASSERT_EQ(lmp->atom->map_tag_max, 6);
+
+    auto x         = lmp->atom->x;
+    auto v         = lmp->atom->v;
+    auto type      = lmp->atom->type;
+    num_bond  = lmp->atom->num_bond;
+    bond_atom = lmp->atom->bond_atom;
+
+    ASSERT_DOUBLE_EQ(x[GETIDX(1)][0], -2.0);
+    ASSERT_DOUBLE_EQ(x[GETIDX(1)][1], 2.0);
+    ASSERT_DOUBLE_EQ(x[GETIDX(1)][2], 0.1);
+    ASSERT_DOUBLE_EQ(x[GETIDX(2)][0], -2.0);
+    ASSERT_DOUBLE_EQ(x[GETIDX(2)][1], -2.0);
+    ASSERT_DOUBLE_EQ(x[GETIDX(2)][2], -0.1);
+    ASSERT_DOUBLE_EQ(x[GETIDX(3)][0], 2.0);
+    ASSERT_DOUBLE_EQ(x[GETIDX(3)][1], 2.0);
+    ASSERT_DOUBLE_EQ(x[GETIDX(3)][2], -0.1);
+    ASSERT_DOUBLE_EQ(x[GETIDX(4)][0], 2.0);
+    ASSERT_DOUBLE_EQ(x[GETIDX(4)][1], -2.0);
+    ASSERT_DOUBLE_EQ(x[GETIDX(4)][2], 0.1);
+    ASSERT_DOUBLE_EQ(x[GETIDX(5)][0], 2.0);
+    ASSERT_DOUBLE_EQ(x[GETIDX(5)][1], 2.0);
+    ASSERT_DOUBLE_EQ(x[GETIDX(5)][2], -2.1);
+    ASSERT_DOUBLE_EQ(x[GETIDX(6)][0], 2.0);
+    ASSERT_DOUBLE_EQ(x[GETIDX(6)][1], -2.0);
+    ASSERT_DOUBLE_EQ(x[GETIDX(6)][2], 2.1);
+    ASSERT_DOUBLE_EQ(v[GETIDX(1)][0], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(1)][1], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(1)][2], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(2)][0], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(2)][1], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(2)][2], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(3)][0], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(3)][1], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(3)][2], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(4)][0], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(4)][1], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(4)][2], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(5)][0], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(5)][1], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(5)][2], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(6)][0], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(6)][1], 0.0);
+    ASSERT_DOUBLE_EQ(v[GETIDX(6)][2], 0.0);
+    ASSERT_EQ(type[GETIDX(1)], 1);
+    ASSERT_EQ(type[GETIDX(2)], 1);
+    ASSERT_EQ(type[GETIDX(3)], 2);
+    ASSERT_EQ(type[GETIDX(4)], 2);
+    ASSERT_EQ(type[GETIDX(5)], 3);
+    ASSERT_EQ(type[GETIDX(6)], 3);
+    ASSERT_EQ(num_bond[GETIDX(1)], 2);
+    ASSERT_EQ(num_bond[GETIDX(2)], 0);
+    ASSERT_EQ(num_bond[GETIDX(3)], 2);
+    ASSERT_EQ(num_bond[GETIDX(4)], 0);
+    ASSERT_EQ(num_bond[GETIDX(5)], 1);
+    ASSERT_EQ(num_bond[GETIDX(6)], 0);
+    ASSERT_EQ(bond_atom[GETIDX(1)][0], 3);
+    ASSERT_EQ(bond_atom[GETIDX(1)][1], 5);
+    ASSERT_EQ(bond_atom[GETIDX(3)][0], 5);
+    ASSERT_EQ(bond_atom[GETIDX(3)][1], 6);
+    ASSERT_EQ(bond_atom[GETIDX(5)][0], 6);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    lmp->input->one("pair_coeff * *");
+    lmp->input->one("group two id 2:4:2");
+    lmp->input->one("delete_atoms group two compress no");
+    lmp->input->one("write_restart test_atom_styles.restart");
+    lmp->input->one("clear");
+    lmp->input->one("read_restart test_atom_styles.restart");
+    lmp->input->one("replicate 1 1 2");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("angle"));
+    ASSERT_NE(lmp->atom->avec, nullptr);
+    ASSERT_EQ(lmp->atom->natoms, 8);
+    ASSERT_EQ(lmp->atom->nlocal, 8);
+    ASSERT_EQ(lmp->atom->nghost, 0);
+    ASSERT_NE(lmp->atom->nmax, -1);
+    ASSERT_EQ(lmp->atom->tag_enable, 1);
+    ASSERT_EQ(lmp->atom->molecular, 1);
+    ASSERT_EQ(lmp->atom->ntypes, 3);
+    ASSERT_EQ(lmp->atom->tag_consecutive(), 0);
+    ASSERT_EQ(lmp->atom->map_tag_max, 12);
+
+    type = lmp->atom->type;
+    ASSERT_EQ(type[GETIDX(1)], 1);
+    ASSERT_EQ(type[GETIDX(3)], 2);
+    ASSERT_EQ(type[GETIDX(5)], 3);
+    ASSERT_EQ(type[GETIDX(6)], 3);
+    ASSERT_EQ(type[GETIDX(7)], 1);
+    ASSERT_EQ(type[GETIDX(9)], 2);
+    ASSERT_EQ(type[GETIDX(11)], 3);
+    ASSERT_EQ(type[GETIDX(12)], 3);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    lmp->input->one("reset_atom_ids");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
+    ASSERT_EQ(lmp->atom->map_tag_max, 8);
+
+    type = lmp->atom->type;
+    ASSERT_EQ(type[GETIDX(1)], 1);
+    ASSERT_EQ(type[GETIDX(2)], 3);
+    ASSERT_EQ(type[GETIDX(3)], 2);
+    ASSERT_EQ(type[GETIDX(4)], 3);
+    ASSERT_EQ(type[GETIDX(5)], 1);
+    ASSERT_EQ(type[GETIDX(6)], 3);
+    ASSERT_EQ(type[GETIDX(7)], 2);
+    ASSERT_EQ(type[GETIDX(8)], 3);
+}
+
 TEST_F(AtomStyleTest, full_ellipsoid)
 {
     if (!LAMMPS::is_installed_pkg("ASPHERE")) GTEST_SKIP();