MPQC 2.3.1

- Main Page
- Related Pages
- Classes
- Files

- File List

pointgrp.h
1 //
2 // pointgrp.h
3 //
4 // Modifications are
5 // Copyright (C) 1996 Limit Point Systems, Inc.
6 //
7 // Author: Edward Seidl <seidl@janed.com>
8 // Maintainer: LPS
9 //
10 // This file is part of the SC Toolkit.
11 //
12 // The SC Toolkit is free software; you can redistribute it and/or modify
13 // it under the terms of the GNU Library General Public License as published by
14 // the Free Software Foundation; either version 2, or (at your option)
15 // any later version.
16 //
17 // The SC Toolkit is distributed in the hope that it will be useful,
18 // but WITHOUT ANY WARRANTY; without even the implied warranty of
19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 // GNU Library General Public License for more details.
21 //
22 // You should have received a copy of the GNU Library General Public License
23 // along with the SC Toolkit; see the file COPYING.LIB. If not, write to
24 // the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
25 //
26 // The U.S. Government is granted a limited license as per AL 91-7.
27 //
28
29 /* pointgrp.h -- definition of the point group classes
30 *
31 * THIS SOFTWARE FITS THE DESCRIPTION IN THE U.S. COPYRIGHT ACT OF A
32 * "UNITED STATES GOVERNMENT WORK". IT WAS WRITTEN AS A PART OF THE
33 * AUTHOR'S OFFICIAL DUTIES AS A GOVERNMENT EMPLOYEE. THIS MEANS IT
34 * CANNOT BE COPYRIGHTED. THIS SOFTWARE IS FREELY AVAILABLE TO THE
35 * PUBLIC FOR USE WITHOUT A COPYRIGHT NOTICE, AND THERE ARE NO
36 * RESTRICTIONS ON ITS USE, NOW OR SUBSEQUENTLY.
37 *
38 * Author:
39 * E. T. Seidl
40 * Bldg. 12A, Rm. 2033
41 * Computer Systems Laboratory
42 * Division of Computer Research and Technology
43 * National Institutes of Health
44 * Bethesda, Maryland 20892
45 * Internet: seidl@alw.nih.gov
46 * June, 1993
47 */
48
49 #ifdef __GNUC__
50 #pragma interface
51 #endif
52
53 #ifndef _math_symmetry_pointgrp_h
54 #define _math_symmetry_pointgrp_h
55
56 #include <iostream>
57
58 #include <util/class/class.h>
59 #include <util/state/state.h>
60 #include <util/keyval/keyval.h>
61 #include <math/scmat/vector3.h>
62
63 namespace sc {
64
65 // //////////////////////////////////////////////////////////////////
66
70 class SymmetryOperation {
71 private:
72 double d[3][3];
73
74 public:
75 SymmetryOperation();
76 SymmetryOperation(const SymmetryOperation &);
77 ~SymmetryOperation();
78
80 double trace() const { return d[0][0]+d[1][1]+d[2][2]; }
81
83 double* operator[](int i) { return d[i]; }
84
86 const double* operator[](int i) const { return d[i]; }
87
90 double& operator()(int i, int j) { return d[i][j]; }
91
93 double operator()(int i, int j) const { return d[i][j]; }
94
96 void zero() { memset(d,0,sizeof(double)*9); }
97
99 SymmetryOperation operate(const SymmetryOperation& r) const;
100
102 SymmetryOperation transform(const SymmetryOperation& r) const;
103
105 void unit() { zero(); d[0][0] = d[1][1] = d[2][2] = 1.0; }
106
108 void E() { unit(); }
109
111 void i() { zero(); d[0][0] = d[1][1] = d[2][2] = -1.0; }
112
114 void sigma_h() { unit(); d[2][2] = -1.0; }
115
117 void sigma_xz() { unit(); d[1][1] = -1.0; }
118
120 void sigma_yz() { unit(); d[0][0] = -1.0; }
121
123 void rotation(int n);
124 void rotation(double theta);
125
127 void c2_x() { i(); d[0][0] = 1.0; }
128
130 void c2_y() { i(); d[1][1] = 1.0; }
131
132 void transpose();
133
135 void print(std::ostream& =ExEnv::out0()) const;
136 };
137
138 // //////////////////////////////////////////////////////////////////
139
145 class SymRep {
146 private:
147 int n;
148 double d[5][5];
149
150 public:
151 SymRep(int =0);
152 SymRep(const SymmetryOperation&);
153 ~SymRep();
154
156 operator SymmetryOperation() const;
157
159 inline double trace() const;
160
162 void set_dim(int i) { n=i; }
163
165 double* operator[](int i) { return d[i]; }
167 const double* operator[](int i) const { return d[i]; }
168
171 double& operator()(int i, int j) { return d[i][j]; }
173 double operator()(int i, int j) const { return d[i][j]; }
174
176 void zero() { memset(d,0,sizeof(double)*25); }
177
179 SymRep operate(const SymRep& r) const;
180
182 SymRep transform(const SymRep& r) const;
183
185 void unit() {
186 zero(); d[0][0] = d[1][1] = d[2][2] = d[3][3] = d[4][4] = 1.0;
187 }
188
190 void E() { unit(); }
191
193 void i() { zero(); d[0][0] = d[1][1] = d[2][2] = d[3][3] = d[4][4] = -1.0;}
194
196 void sigma_h();
197
199 void sigma_xz();
200
202 void sigma_yz();
203
205 void rotation(int n);
206 void rotation(double theta);
207
209 void c2_x();
210
212 void c2_y();
213
215 void print(std::ostream& =ExEnv::out0()) const;
216 };
217
218 inline double
219 SymRep::trace() const
220 {
221 double r=0;
222 for (int i=0; i < n; i++)
223 r += d[i][i];
224 return r;
225 }
226
227 // //////////////////////////////////////////////////////////////////
228
229
230 class CharacterTable;
231
239 class IrreducibleRepresentation {
240 friend class CharacterTable;
241
242 private:
243 int g; // the order of the group
244 int degen; // the degeneracy of the irrep
245 int nrot_; // the number of rotations in this irrep
246 int ntrans_; // the number of translations in this irrep
247 int complex_; // true if this irrep has a complex representation
248 char *symb; // mulliken symbol for this irrep
249 char *csymb; // mulliken symbol for this irrep w/o special characters
250
251 SymRep *rep; // representation matrices for the symops
252
253 public:
254 IrreducibleRepresentation();
255 IrreducibleRepresentation(const IrreducibleRepresentation&);
259 IrreducibleRepresentation(int,int,const char*,const char* =0);
260
261 ~IrreducibleRepresentation();
262
263 IrreducibleRepresentation& operator=(const IrreducibleRepresentation&);
264
266 void init(int =0, int =0, const char* =0, const char* =0);
267
269 int order() const { return g; }
270
272 int degeneracy() const { return degen; }
273
275 int complex() const { return complex_; }
276
278 int nproj() const { return degen*degen; }
279
281 int nrot() const { return nrot_; }
282
284 int ntrans() const { return ntrans_; }
285
287 const char * symbol() const { return symb; }
288
292 const char * symbol_ns() const { return (csymb?csymb:symb); }
293
296 double character(int i) const {
297 return complex_ ? 0.5*rep[i].trace() : rep[i].trace();
298 }
299
301 double p(int x1, int x2, int i) const { return rep[i](x1,x2); }
302
305 double p(int d, int i) const {
306 int dc=d/degen; int dr=d%degen;
307 return rep[i](dr,dc);
308 }
309
313 void print(std::ostream& =ExEnv::out0()) const;
314 };
315
316 // ///////////////////////////////////////////////////////////
325 class CharacterTable {
326 public:
327 enum pgroups {C1, CS, CI, CN, CNV, CNH, DN, DND, DNH, SN, T, TH, TD, O,
328 OH, I, IH};
329
330 private:
331 int g; // the order of the point group
332 int nt; // order of the princ rot axis
333 pgroups pg; // the class of the point group
334 int nirrep_; // the number of irreps in this pg
335 IrreducibleRepresentation *gamma_; // an array of irreps
336 SymmetryOperation *symop; // the matrices describing sym ops
337 int *_inv; // index of the inverse symop
338 char *symb; // the Schoenflies symbol for the pg
339
341 int parse_symbol();
343 int make_table();
344
345 // these create the character tables for the cubic groups
346 void t();
347 void th();
348 void td();
349 void o();
350 void oh();
351 void i();
352 void ih();
353
354 public:
355 CharacterTable();
358 CharacterTable(const char*);
362 CharacterTable(const char*,const SymmetryOperation&);
363
364 CharacterTable(const CharacterTable&);
365 ~CharacterTable();
366
367 CharacterTable& operator=(const CharacterTable&);
368
370 int nirrep() const { return nirrep_; }
372 int order() const { return g; }
374 const char * symbol() const { return symb; }
376 IrreducibleRepresentation& gamma(int i) { return gamma_[i]; }
378 SymmetryOperation& symm_operation(int i) { return symop[i]; }
379
383 int complex() const {
384 if (pg==CN || pg==SN || pg==CNH || pg==T || pg==TH)
385 return 1;
386 return 0;
387 }
388
390 int inverse(int i) const { return _inv[i]; }
391
392 int ncomp() const {
393 int ret=0;
394 for (int i=0; i < nirrep_; i++) {
395 int nc = (gamma_[i].complex()) ? 1 : gamma_[i].degen;
396 ret += nc;
397 }
398 return ret;
399 }
400
402 int which_irrep(int i) {
403 for (int ir=0, cn=0; ir < nirrep_; ir++) {
404 int nc = (gamma_[ir].complex()) ? 1 : gamma_[ir].degen;
405 for (int c=0; c < nc; c++,cn++)
406 if (cn==i)
407 return ir;
408 }
409 return -1;
410 }
411
413 int which_comp(int i) {
414 for (int ir=0, cn=0; ir < nirrep_; ir++) {
415 int nc = (gamma_[ir].complex()) ? 1 : gamma_[ir].degen;
416 for (int c=0; c < nc; c++,cn++)
417 if (cn==i)
418 return c;
419 }
420 return -1;
421 }
422
424 void print(std::ostream& =ExEnv::out0()) const;
425 };
426
427 // ///////////////////////////////////////////////////////////
428
436 class PointGroup: public SavableState {
437 private:
438 char *symb;
439 SymmetryOperation frame;
440 SCVector3 origin_;
441
442 public:
443 PointGroup();
446 PointGroup(const char*);
449 PointGroup(const char*,SymmetryOperation&);
452 PointGroup(const char*,SymmetryOperation&,const SCVector3&);
487 PointGroup(const Ref<KeyVal>&);
488
489 PointGroup(StateIn&);
490 PointGroup(const PointGroup&);
491 PointGroup(const Ref<PointGroup>&);
492 ~PointGroup();
493
494 PointGroup& operator=(const PointGroup&);
495
497 int equiv(const Ref<PointGroup> &, double tol = 1.0e-6) const;
498
500 CharacterTable char_table() const;
502 const char * symbol() const { return symb; }
504 SymmetryOperation& symm_frame() { return frame; }
506 const SymmetryOperation& symm_frame() const { return frame; }
508 SCVector3& origin() { return origin_; }
509 const SCVector3& origin() const { return origin_; }
510
512 void set_symbol(const char*);
513
514 void save_data_state(StateOut& so);
515
516 void print(std::ostream&o=ExEnv::out0()) const;
517 };
518
519 }
520
521 #endif
522
523 // Local Variables:
524 // mode: c++
525 // c-file-style: "ETS"
526 // End: