OOPSE/libBASS/RigidBodyStamp.cpp

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iostream>

#include "RigidBodyStamp.hpp"

char RigidBodyStamp::errMsg[500];

RigidBodyStamp::RigidBodyStamp(){
  
  unhandled = NULL;
  have_position = 0;
  have_orientation = 0;
  have_atoms = 0;
  have_extras = 0;
}

RigidBodyStamp::~RigidBodyStamp(){
  int i;
  
  if( unhandled != NULL ) delete unhandled;

  if( atoms != NULL ){
    for( i=0; i<n_atoms; i++ ) delete atoms[i];
  }
}

void RigidBodyStamp::setPosition( double x, double y, double z ){

  pos[0] = x;
  pos[1] = y;
  pos[2] = z;

  // Do I tell atoms about this?

  have_position = 1;
}

void RigidBodyStamp::setOrientation( double phi, double theta, double psi ){

  // in order of application (see Goldstein)

  ornt[0] = phi;
  ornt[1] = theta;
  ornt[2] = psi;

  // Do I tell atoms about this?

  have_orientation = 1;
}

char* RigidBodyStamp::assignString( char* lhs, char* rhs ){

  if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
  else unhandled->add( lhs, rhs );
  have_extras = 1;
  return NULL;
}

char* RigidBodyStamp::assignDouble( char* lhs, double rhs ){
  int i;

  if( !strcmp( lhs, "nAtoms" ) ){
    n_atoms = (int)rhs;

    if( have_atoms ){
      sprintf( errMsg,
               "RigidBodyStamp error, n_atoms already declared"
               " for this RigidBody.\n");
      return strdup( errMsg );
    }
    have_atoms = 1;
    atoms = new AtomStamp*[n_atoms];
    for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
  } 
  else {
    if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
    else unhandled->add( lhs, rhs );
    have_extras = 1;
  }
  return NULL;
}

char* RigidBodyStamp::assignInt( char* lhs, int rhs ){
  int i;

  if( !strcmp( lhs, "nAtoms" ) ){
    n_atoms = rhs;

    if( have_atoms ){
      sprintf( errMsg,
               "RigidBodyStamp error, n_atoms already declared for"
               " this RigidBody.\n");
      return strdup( errMsg );
    }
    have_atoms = 1;
    atoms = new AtomStamp*[n_atoms];
    for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
  }
  else {  
    if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
    else unhandled->add( lhs, rhs );
    have_extras = 1;
  }
  return NULL;
}

char* RigidBodyStamp::addAtom( AtomStamp* the_atom, int atomIndex ){
  
  if( have_atoms && atomIndex < n_atoms ) atoms[atomIndex] = the_atom;
  else{
    if( have_atoms ){
      sprintf( errMsg, "RigidBodyStamp error, %d out of nAtoms range",
               atomIndex );
      return strdup( errMsg );
    }
    else return strdup("RigidBodyStamp error, nAtoms not given before"
                       "first atom declaration." );
  }
  return NULL;
}

char* RigidBodyStamp::checkMe( void ){

  int i;
  short int no_atom;
  
  if( !have_atoms ){
    return strdup( "RigidBodyStamp error. RigidBody contains no atoms." );
  }
  
  no_atom = 0;
  for( i=0; i<n_atoms; i++ ){
    if( atoms[i] == NULL ) no_atom = 1;
  }
  
  if( no_atom ){
    sprintf( errMsg,
             "RigidBodyStamp error. Not all of the atoms were"
             " declared in this RigidBody.");
    return strdup( errMsg );
  }
  
  return NULL;
  
}
Revision:	982
Committed:	Mon Jan 26 21:26:40 2004 UTC (20 years, 7 months ago) by gezelter
File size:	3155 byte(s)
Log Message:	Changed default orientation in BASS to use Euler angles in the following order: phi, theta, psi Removed the ability to set orientation using a unit vector
#	User	Rev	Content
1	gezelter	957	#include <stdlib.h>
2			#include <stdio.h>
3			#include <string.h>
4			#include <iostream>
5
6			#include "RigidBodyStamp.hpp"
7
8			char RigidBodyStamp::errMsg[500];
9
10			RigidBodyStamp::RigidBodyStamp(){
11
12			unhandled = NULL;
13			have_position = 0;
14			have_orientation = 0;
15			have_atoms = 0;
16			have_extras = 0;
17			}
18
19			RigidBodyStamp::~RigidBodyStamp(){
20			int i;
21
22			if( unhandled != NULL ) delete unhandled;
23
24			if( atoms != NULL ){
25			for( i=0; i<n_atoms; i++ ) delete atoms[i];
26			}
27			}
28
29			void RigidBodyStamp::setPosition( double x, double y, double z ){
30
31			pos[0] = x;
32			pos[1] = y;
33			pos[2] = z;
34
35			// Do I tell atoms about this?
36
37			have_position = 1;
38			}
39
40	gezelter	982	void RigidBodyStamp::setOrientation( double phi, double theta, double psi ){
41	gezelter	957
42	gezelter	982	// in order of application (see Goldstein)
43	gezelter	957
44	gezelter	982	ornt[0] = phi;
45			ornt[1] = theta;
46			ornt[2] = psi;
47
48	gezelter	957	// Do I tell atoms about this?
49
50			have_orientation = 1;
51			}
52
53			char* RigidBodyStamp::assignString( char* lhs, char* rhs ){
54
55	gezelter	982	if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
56			else unhandled->add( lhs, rhs );
57			have_extras = 1;
58	gezelter	957	return NULL;
59			}
60
61			char* RigidBodyStamp::assignDouble( char* lhs, double rhs ){
62			int i;
63
64			if( !strcmp( lhs, "nAtoms" ) ){
65			n_atoms = (int)rhs;
66
67			if( have_atoms ){
68			sprintf( errMsg,
69			"RigidBodyStamp error, n_atoms already declared"
70	gezelter	982	" for this RigidBody.\n");
71	gezelter	957	return strdup( errMsg );
72			}
73			have_atoms = 1;
74			atoms = new AtomStamp*[n_atoms];
75			for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
76			}
77			else {
78			if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
79			else unhandled->add( lhs, rhs );
80			have_extras = 1;
81			}
82			return NULL;
83			}
84
85			char* RigidBodyStamp::assignInt( char* lhs, int rhs ){
86			int i;
87
88			if( !strcmp( lhs, "nAtoms" ) ){
89			n_atoms = rhs;
90
91			if( have_atoms ){
92			sprintf( errMsg,
93			"RigidBodyStamp error, n_atoms already declared for"
94	gezelter	982	" this RigidBody.\n");
95	gezelter	957	return strdup( errMsg );
96			}
97			have_atoms = 1;
98			atoms = new AtomStamp*[n_atoms];
99			for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
100			}
101			else {
102			if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
103			else unhandled->add( lhs, rhs );
104			have_extras = 1;
105			}
106			return NULL;
107			}
108
109			char* RigidBodyStamp::addAtom( AtomStamp* the_atom, int atomIndex ){
110
111			if( have_atoms && atomIndex < n_atoms ) atoms[atomIndex] = the_atom;
112			else{
113			if( have_atoms ){
114			sprintf( errMsg, "RigidBodyStamp error, %d out of nAtoms range",
115			atomIndex );
116			return strdup( errMsg );
117			}
118			else return strdup("RigidBodyStamp error, nAtoms not given before"
119			"first atom declaration." );
120			}
121			return NULL;
122			}
123
124			char* RigidBodyStamp::checkMe( void ){
125
126			int i;
127			short int no_atom;
128
129	gezelter	982	if( !have_atoms ){
130			return strdup( "RigidBodyStamp error. RigidBody contains no atoms." );
131	gezelter	957	}
132
133			no_atom = 0;
134			for( i=0; i<n_atoms; i++ ){
135			if( atoms[i] == NULL ) no_atom = 1;
136			}
137
138			if( no_atom ){
139			sprintf( errMsg,
140			"RigidBodyStamp error. Not all of the atoms were"
141	gezelter	982	" declared in this RigidBody.");
142	gezelter	957	return strdup( errMsg );
143			}
144
145			return NULL;
146
147			}