NAMD
Functions
DumpBench.h File Reference

Go to the source code of this file.

Functions

int dumpbench (FILE *)
 

Function Documentation

◆ dumpbench()

int dumpbench ( FILE *  )

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 27 of file DumpBench.C.

References LJTable::TableEntry::A, angle::angle_type, AtomSignature::angleCnt, AtomSignature::angleSigs, bond::atom2, angle::atom2, dihedral::atom2, improper::atom2, angle::atom3, dihedral::atom3, improper::atom3, dihedral::atom4, improper::atom4, CompAtomExt::atomFixed, Molecule::atomvdwtype(), LJTable::TableEntry::B, bond::bond_type, AtomSignature::bondCnt, AtomSignature::bondSigs, CompAtom::charge, computeNonbondedPairType, dihedral::dihedral_type, AtomSignature::dihedralCnt, AtomSignature::dihedralSigs, ExclusionCheck::flags, Molecule::get_angle(), Molecule::get_angles_for_atom(), Molecule::get_bond(), Molecule::get_bonds_for_atom(), Molecule::get_dihedral(), Molecule::get_dihedrals_for_atom(), Molecule::get_excl_check_for_atom(), Molecule::get_improper(), Molecule::get_impropers_for_atom(), LJTable::get_table(), LJTable::get_table_dim(), HomePatch::getAtomList(), Patch::getNumAtoms(), CompAtomExt::groupFixed, PatchMap::homePatch(), CompAtom::hydrogenGroupSize, CompAtomExt::id, improper::improper_type, AtomSignature::improperCnt, AtomSignature::improperSigs, ComputeNonbondedUtil::ljTable, ExclusionCheck::max, ExclusionCheck::min, Node::molecule, CompAtom::nonbondedGroupSize, Molecule::numAngles, Molecule::numAtoms, Molecule::numBonds, Molecule::numCalcAngles, Molecule::numCalcBonds, Molecule::numCalcDihedrals, Molecule::numCalcExclusions, Molecule::numCalcImpropers, ComputeMap::numComputes(), Molecule::numDihedrals, Molecule::numImpropers, PatchMap::numPatches(), PatchMap::Object(), Node::Object(), ComputeMap::Object(), CompAtom::partition, ComputeMap::partition(), ComputeMap::pid(), CompAtom::position, Node::simParameters, simParams, ComputeMap::trans(), TupleSignature::tupleParamType, ComputeMap::type(), Vector::x, Vector::y, and Vector::z.

27  {
28 
29  Node *node = Node::Object();
30 
31  fprintf(file,"SIMPARAMETERS_BEGIN\n");
32 
33  SimParameters *simParams = node->simParameters;
34 
35 #define SIMPARAM(T,N,V) dump_param(file,#N,simParams->N)
36 #include "DumpBenchParams.h"
37 #undef SIMPARAM
38 
39  fprintf(file,"SIMPARAMETERS_END\n");
40 
41  fprintf(file,"LJTABLE_BEGIN\n");
42 
43  const LJTable *ljTable = ComputeNonbondedUtil::ljTable;
44 
45  int table_dim = ljTable->get_table_dim();
46  fprintf(file,"%d\n",table_dim);
47 
48  const LJTable::TableEntry *table = ljTable->get_table();
49  int i,j;
50  for ( i=0; i < table_dim; ++i) {
51  for ( j=i; j < table_dim; ++j)
52  {
53  const LJTable::TableEntry *curij = &(table[2*(i*table_dim+j)]);
54  fprintf(file,"%g %g %g %g\n",curij->A,curij->B,
55  (curij+1)->A,(curij+1)->B);
56  }
57  }
58 
59  fprintf(file,"LJTABLE_END\n");
60 
61  fprintf(file,"MOLECULE_BEGIN\n");
62 
63  const Molecule *mol = node->molecule;
64 
65  fprintf(file,"%d %ld\n",mol->numAtoms,mol->numCalcExclusions);
66 
67  for ( i=0; i<mol->numAtoms; ++i) {
68  int vdw = mol->atomvdwtype(i);
69  #ifdef MEM_OPT_VERSION
70  Index exclIdx = mol->getAtomExclSigId(i);
71  const ExclusionCheck *excl = mol->get_excl_check_for_idx(exclIdx);
72  //if(excl->flags==NULL || excl->flags == (char *)-1){
73  // fprintf(file,"%d: %d ====\n",i, vdw);
74  // continue;
75  //}
76  int min = i+excl->min;
77  int max = i+excl->max;
78  #else
79  const ExclusionCheck *excl = mol->get_excl_check_for_atom(i);
80  //if(excl->flags==NULL || excl->flags == (char *)-1){
81  // fprintf(file,"%d: %d ====\n",i, vdw);
82  // continue;
83  //}
84  int min = excl->min;
85  int max = excl->max;
86  #endif
87  // fprintf(file,"%d: %d %d %d |",i,vdw,min,max);
88  fprintf(file,"%d %d %d",vdw,min,max);
89  if ( min <= max ) {
90  int s = max - min + 1;
91  const char *f = excl->flags;
92  for ( int k=0; k<s; ++k ) {
93  int fk = f[k];
94  fprintf(file," %d",fk);
95  }
96  }
97  fprintf(file,"\n");
98  }
99 
100  fprintf(file,"MOLECULE_END\n");
101 
102 #if 0
103  fprintf(file, "BONDS_BEGIN\n");
104  fprintf(file, "%d %d\n", mol->numBonds, mol->numCalcBonds);
105 #ifdef MEM_OPT_VERSION
106  for(i=0; i<mol->numAtoms; i++){
107  int sigId = node->molecule->getAtomSigId(i);
108  AtomSignature *sig = &(mol->atomSigPool[sigId]);
109  if(sig->bondCnt==0){
110  fprintf(file, "%d: ===\n", i);
111  continue;
112  }
113  fprintf(file, "%d:", i);
114  for(j=0; j<sig->bondCnt; j++){
115  fprintf(file, " (%d | %d)", (sig->bondSigs[j]).offset[0], sig->bondSigs[j].tupleParamType);
116  }
117  fprintf(file, "\n");
118  }
119 #else
120  for(i=0; i<mol->numAtoms; i++){
121  int *p = node->molecule->get_bonds_for_atom(i);
122  if(*p==-1){
123  fprintf(file, "%d: ===\n", i);
124  continue;
125  }
126  fprintf(file, "%d:", i);
127  for(; *p!=-1;p++){
128  Bond *t = mol->get_bond(*p);
129  fprintf(file, " (%d | %d)", t->atom2-i, t->bond_type);
130  }
131  fprintf(file, "\n");
132  }
133 #endif
134  fprintf(file, "BONDS_END\n");
135 
136  fprintf(file, "ANGLES_BEGIN\n");
137  fprintf(file, "%d %d\n", mol->numAngles, mol->numCalcAngles);
138 #ifdef MEM_OPT_VERSION
139  for(i=0; i<mol->numAtoms; i++){
140  int sigId = node->molecule->getAtomSigId(i);
141  AtomSignature *sig = &(mol->atomSigPool[sigId]);
142  if(sig->angleCnt==0){
143  fprintf(file, "%d: ===\n", i);
144  continue;
145  }
146  fprintf(file, "%d:", i);
147  for(j=0; j<sig->angleCnt; j++){
148  int offset0 = (sig->angleSigs[j]).offset[0];
149  int offset1 = (sig->angleSigs[j]).offset[1];
150  fprintf(file, " (%d, %d | %d)", offset0, offset1, sig->angleSigs[j].tupleParamType);
151  }
152  fprintf(file, "\n");
153  }
154 #else
155  for(i=0; i<mol->numAtoms; i++){
156  int *p = node->molecule->get_angles_for_atom(i);
157  if(*p==-1){
158  fprintf(file, "%d: ===\n", i);
159  continue;
160  }
161  fprintf(file, "%d:", i);
162  for(; *p!=-1;p++){
163  Angle *t = mol->get_angle(*p);
164  int offset0 = t->atom2 - i;
165  int offset1 = t->atom3 - i;
166  fprintf(file, " (%d, %d | %d)", offset0, offset1, t->angle_type);
167  }
168  fprintf(file, "\n");
169  }
170 #endif
171  fprintf(file, "ANGLES_END\n");
172 
173  fprintf(file, "DIHEDRALS_BEGIN\n");
174  fprintf(file, "%d %d\n", mol->numDihedrals, mol->numCalcDihedrals);
175 #ifdef MEM_OPT_VERSION
176  for(i=0; i<mol->numAtoms; i++){
177  int sigId = node->molecule->getAtomSigId(i);
178  AtomSignature *sig = &(mol->atomSigPool[sigId]);
179  if(sig->dihedralCnt==0){
180  fprintf(file, "%d: ===\n", i);
181  continue;
182  }
183  fprintf(file, "%d:", i);
184  for(j=0; j<sig->dihedralCnt; j++){
185  int offset0 = (sig->dihedralSigs[j]).offset[0];
186  int offset1 = (sig->dihedralSigs[j]).offset[1];
187  int offset2 = (sig->dihedralSigs[j]).offset[2];
188  fprintf(file, " (%d, %d, %d | %d)", offset0, offset1, offset2, sig->dihedralSigs[j].tupleParamType);
189  }
190  fprintf(file, "\n");
191  }
192 #else
193  for(i=0; i<mol->numAtoms; i++){
194  int *p = node->molecule->get_dihedrals_for_atom(i);
195  if(*p==-1){
196  fprintf(file, "%d: ===\n", i);
197  continue;
198  }
199  fprintf(file, "%d:", i);
200  for(; *p!=-1;p++){
201  Dihedral *t = mol->get_dihedral(*p);
202  int offset0 = t->atom2 - i;
203  int offset1 = t->atom3 - i;
204  int offset2 = t->atom4 - i;
205  fprintf(file, " (%d, %d, %d | %d)", offset0, offset1, offset2, t->dihedral_type);
206  }
207  fprintf(file, "\n");
208  }
209 #endif
210  fprintf(file, "DIHEDRALS_END\n");
211 
212  fprintf(file, "IMPROPERS_BEGIN\n");
213  fprintf(file, "%d %d\n", mol->numImpropers, mol->numCalcImpropers);
214 #ifdef MEM_OPT_VERSION
215  for(i=0; i<mol->numAtoms; i++){
216  int sigId = node->molecule->getAtomSigId(i);
217  AtomSignature *sig = &(mol->atomSigPool[sigId]);
218  if(sig->improperCnt==0){
219  fprintf(file, "%d: ===\n", i);
220  continue;
221  }
222  fprintf(file, "%d:", i);
223  for(j=0; j<sig->improperCnt; j++){
224  int offset0 = (sig->improperSigs[j]).offset[0];
225  int offset1 = (sig->improperSigs[j]).offset[1];
226  int offset2 = (sig->improperSigs[j]).offset[2];
227  fprintf(file, " (%d, %d, %d | %d)", offset0, offset1, offset2, sig->improperSigs[j].tupleParamType);
228  }
229  fprintf(file, "\n");
230  }
231 #else
232  for(i=0; i<mol->numAtoms; i++){
233  int *p = node->molecule->get_impropers_for_atom(i);
234  if(*p==-1){
235  fprintf(file, "%d: ===\n", i);
236  continue;
237  }
238  fprintf(file, "%d:", i);
239  for(; *p!=-1;p++){
240  Improper *t = mol->get_improper(*p);
241  int offset0 = t->atom2 - i;
242  int offset1 = t->atom3 - i;
243  int offset2 = t->atom4 - i;
244  fprintf(file, " (%d, %d, %d | %d)", offset0, offset1, offset2, t->improper_type);
245  }
246  fprintf(file, "\n");
247  }
248 #endif
249  fprintf(file, "IMPROPERS_END\n");
250 #endif
251 
252  fprintf(file,"PATCHLIST_BEGIN\n");
253 
254  PatchMap *patchMap = PatchMap::Object();
255  int numPatches = patchMap->numPatches();
256  fprintf(file,"%d\n",numPatches);
257 
258  for ( i=0; i<numPatches; ++i) {
259  HomePatch *patch = patchMap->homePatch(i);
260  fprintf(file,"PATCH_BEGIN\n");
261  int numAtoms = patch->getNumAtoms();
262  fprintf(file,"%d\n",numAtoms);
263  FullAtomList &atoms = patch->getAtomList();
264  for ( j=0; j<numAtoms; ++j) {
265  FullAtom &a = atoms[j];
266  double x,y,z,q;
267  int id,hgs,ngia,af,gf,part;
268  x = a.position.x;
269  y = a.position.y;
270  z = a.position.z;
271  q = a.charge;
272  id = a.id;
273  hgs = a.hydrogenGroupSize;
274  ngia = ( hgs != 1 && a.nonbondedGroupSize == 1 ) ? 1 : 0;
275  af = a.atomFixed;
276  gf = a.groupFixed;
277  part = a.partition;
278  fprintf(file,"%f %f %f %f %d %d %d %d %d %d\n",
279  x,y,z,q,id,hgs,ngia,af,gf,part);
280  }
281  fprintf(file,"PATCH_END\n");
282  }
283 
284  fprintf(file,"PATCHLIST_END\n");
285 
286  fprintf(file,"COMPUTEPAIR_BEGIN\n");
287 
288  ComputeMap *computeMap = ComputeMap::Object();
289  int numComputes = computeMap->numComputes();
290  int numPairComputes = 0;
291  for ( i=0; i<numComputes; ++i) {
292  if ( computeMap->type(i) == computeNonbondedPairType
293  && computeMap->partition(i) == 0 ) ++numPairComputes;
294  }
295  fprintf(file,"%d\n",numPairComputes);
296  for ( i=0; i<numComputes; ++i) {
297  if ( computeMap->type(i) == computeNonbondedPairType
298  && computeMap->partition(i) == 0 ) {
299  int pid1 = computeMap->pid(i,0);
300  int trans1 = computeMap->trans(i,0);
301  int pid2 = computeMap->pid(i,1);
302  int trans2 = computeMap->trans(i,1);
303  fprintf(file,"%d %d %d %d\n",pid1,trans1,pid2,trans2);
304  }
305  }
306 
307  fprintf(file,"COMPUTEPAIR_END\n");
308 
309  return 0;
310 }
Node::Object
static Node * Object()
Definition: Node.h:86
improper::atom4
int32 atom4
Definition: structures.h:77
improper::improper_type
Index improper_type
Definition: structures.h:78
Patch::getNumAtoms
int getNumAtoms() const
Definition: Patch.h:105
Molecule::get_dihedrals_for_atom
int32 * get_dihedrals_for_atom(int anum)
Definition: Molecule.h:1224
Molecule::numCalcBonds
int numCalcBonds
Definition: Molecule.h:657
Molecule::numBonds
int numBonds
Definition: Molecule.h:589
ComputeMap::numComputes
int numComputes(void)
Definition: ComputeMap.h:103
Node
Definition: Node.h:78
dihedral::atom3
int32 atom3
Definition: structures.h:67
PatchMap::Object
static PatchMap * Object()
Definition: PatchMap.h:27
AtomSignature::improperSigs
TupleSignature * improperSigs
Definition: structures.h:346
Node::simParameters
SimParameters * simParameters
Definition: Node.h:181
AtomSignature::dihedralSigs
TupleSignature * dihedralSigs
Definition: structures.h:345
ExclusionCheck::flags
char * flags
Definition: Molecule.h:71
LJTable::get_table
const TableEntry * get_table() const
Definition: LJTable.h:43
Vector::z
BigReal z
Definition: Vector.h:74
CompAtom::position
Position position
Definition: NamdTypes.h:78
CompAtomExt::groupFixed
uint32 groupFixed
Definition: NamdTypes.h:163
PatchMap::homePatch
HomePatch * homePatch(PatchID pid)
Definition: PatchMap.h:249
Molecule::get_dihedral
Dihedral * get_dihedral(int dnum) const
Definition: Molecule.h:1150
Molecule::get_excl_check_for_atom
const ExclusionCheck * get_excl_check_for_atom(int anum) const
Definition: Molecule.h:1248
Molecule
Molecule stores the structural information for the system.
Definition: Molecule.h:174
Molecule::get_angles_for_atom
int32 * get_angles_for_atom(int anum)
Definition: Molecule.h:1222
CompAtomExt::id
uint32 id
Definition: NamdTypes.h:160
CompAtom::charge
Charge charge
Definition: NamdTypes.h:79
dihedral::atom4
int32 atom4
Definition: structures.h:68
Index
int Index
Definition: structures.h:26
Molecule::get_angle
Angle * get_angle(int anum) const
Definition: Molecule.h:1144
HomePatch::getAtomList
FullAtomList & getAtomList()
Definition: HomePatch.h:528
PatchMap::numPatches
int numPatches(void) const
Definition: PatchMap.h:59
dihedral::dihedral_type
Index dihedral_type
Definition: structures.h:69
Molecule::get_impropers_for_atom
int32 * get_impropers_for_atom(int anum)
Definition: Molecule.h:1226
ComputeMap::type
ComputeType type(ComputeID cid)
Definition: ComputeMap.C:118
angle::atom2
int32 atom2
Definition: structures.h:58
Molecule::atomvdwtype
Index atomvdwtype(int anum) const
Definition: Molecule.h:1134
LJTable::get_table_dim
int get_table_dim() const
Definition: LJTable.h:44
Molecule::get_bonds_for_atom
int32 * get_bonds_for_atom(int anum)
Definition: Molecule.h:1220
Molecule::numCalcDihedrals
int numCalcDihedrals
Definition: Molecule.h:659
angle::atom3
int32 atom3
Definition: structures.h:59
CompAtom::partition
uint8 partition
Definition: NamdTypes.h:81
Vector::x
BigReal x
Definition: Vector.h:74
CompAtom::hydrogenGroupSize
uint8 hydrogenGroupSize
Definition: NamdTypes.h:89
Molecule::numCalcImpropers
int numCalcImpropers
Definition: Molecule.h:660
Molecule::numAngles
int numAngles
Definition: Molecule.h:590
Molecule::numAtoms
int numAtoms
Definition: Molecule.h:586
AtomSignature::bondSigs
TupleSignature * bondSigs
Definition: structures.h:343
ComputeMap::partition
int partition(ComputeID cid)
Definition: ComputeMap.C:126
angle::angle_type
Index angle_type
Definition: structures.h:60
Molecule::numDihedrals
int numDihedrals
Definition: Molecule.h:591
dihedral::atom2
int32 atom2
Definition: structures.h:66
Molecule::numImpropers
int numImpropers
Definition: Molecule.h:596
Molecule::numCalcExclusions
int64 numCalcExclusions
Definition: Molecule.h:662
CompAtom::nonbondedGroupSize
uint8 nonbondedGroupSize
Definition: NamdTypes.h:82
simParams
#define simParams
Definition: Output.C:131
ComputeMap::Object
static ComputeMap * Object()
Definition: ComputeMap.h:91
Vector::y
BigReal y
Definition: Vector.h:74
ComputeNonbondedUtil::ljTable
static const LJTable * ljTable
Definition: ComputeNonbondedUtil.h:295
TupleSignature::tupleParamType
Index tupleParamType
Definition: structures.h:212
improper::atom2
int32 atom2
Definition: structures.h:75
ComputeMap::pid
int pid(ComputeID cid, int i)
Definition: ComputeMap.C:107
Molecule::get_bond
Bond * get_bond(int bnum) const
Definition: Molecule.h:1141
bond::bond_type
Index bond_type
Definition: structures.h:52
ComputeMap::trans
int trans(ComputeID cid, int i)
Definition: ComputeMap.C:112
CompAtomExt::atomFixed
uint32 atomFixed
Definition: NamdTypes.h:162
Node::molecule
Molecule * molecule
Definition: Node.h:179
improper::atom3
int32 atom3
Definition: structures.h:76
AtomSignature::angleSigs
TupleSignature * angleSigs
Definition: structures.h:344
Molecule::numCalcAngles
int numCalcAngles
Definition: Molecule.h:658
bond::atom2
int32 atom2
Definition: structures.h:51
Molecule::get_improper
Improper * get_improper(int inum) const
Definition: Molecule.h:1147
Generated by   doxygen 1.8.14