MPQC
2.3.1
Main Page
Related Pages
Classes
Files
File List
src
lib
math
symmetry
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:
Generated at Wed Sep 25 2013 06:53:57 for
MPQC
2.3.1 using the documentation package
Doxygen
1.8.3.1.