MPQC 2.3.1
chemistry/qc/basis/transform.h
1//
2// transform.h
3//
4// Copyright (C) 1996 Limit Point Systems, Inc.
5//
6// Author: Curtis Janssen <cljanss@limitpt.com>
7// Maintainer: LPS
8//
9// This file is part of the SC Toolkit.
10//
11// The SC Toolkit is free software; you can redistribute it and/or modify
12// it under the terms of the GNU Library General Public License as published by
13// the Free Software Foundation; either version 2, or (at your option)
14// any later version.
15//
16// The SC Toolkit is distributed in the hope that it will be useful,
17// but WITHOUT ANY WARRANTY; without even the implied warranty of
18// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19// GNU Library General Public License for more details.
20//
21// You should have received a copy of the GNU Library General Public License
22// along with the SC Toolkit; see the file COPYING.LIB. If not, write to
23// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
24//
25// The U.S. Government is granted a limited license as per AL 91-7.
26//
27
28#if defined(__GNUC__)
29#pragma interface
30#endif
31
32#ifndef _chemistry_qc_basis_transform_h
33#define _chemistry_qc_basis_transform_h
34
35namespace sc {
36
37// ///////////////////////////////////////////////////////////////////////////
38
42 protected:
43 double coef_;
44 int a_, b_, c_, cartindex_, pureindex_;
45
46 public:
48 int a() const { return a_; }
50 int b() const { return b_; }
52 int c() const { return c_; }
54 int cartindex() const { return cartindex_; }
56 int pureindex() const { return pureindex_; }
58 double coef() const { return coef_; }
59
68 virtual void init(int a, int b, int c, double coef, int pureindex) =0;
69};
70
71// ///////////////////////////////////////////////////////////////////////////
72
76 protected:
77 int n_;
78 int l_;
79 int subl_;
80 SphericalTransformComponent *components_;
81
83
91 SphericalTransform(int l, int subl = -1);
92
97 virtual void init();
98
99 public:
100 virtual ~SphericalTransform();
101
103 void add(int a, int b, int c, double coef, int pureindex);
104
106 int cartindex(int i) const { return components_[i].cartindex(); }
108 int pureindex(int i) const { return components_[i].pureindex(); }
110 double coef(int i) const { return components_[i].coef(); }
112 int a(int i) const { return components_[i].a(); }
114 int b(int i) const { return components_[i].b(); }
116 int c(int i) const { return components_[i].c(); }
118 int l() const { return l_; }
120 int n() const { return n_; }
121
125};
126
129 protected:
131 ISphericalTransform(int l,int subl=-1);
132 void init();
133};
134
135// ///////////////////////////////////////////////////////////////////////////
136
139 private:
140 int i_;
141
142 protected:
143 const SphericalTransform *transform_;
144
145 public:
148
149 void begin() { i_ = 0; }
150 void start() { begin(); }
151 void next() { i_++; }
152 int ready() { return i_ < transform_->n(); }
153 operator int() { return ready(); }
154 int l() { return transform_->l(); }
155 int cartindex() { return transform_->cartindex(i_); }
156 int pureindex() { return transform_->pureindex(i_); }
157 int bfn() { return pureindex(); }
158 double coef() { return transform_->coef(i_); }
159 int a() { return transform_->a(i_); }
160 int b() { return transform_->b(i_); }
161 int c() { return transform_->c(i_); }
162 int l(int i) { return i?(i==1?b():c()):a(); }
163 int n() { return 2*l() + 1; }
164};
165
166}
167
168#endif
169
170// Local Variables:
171// mode: c++
172// c-file-style: "ETS"
173// End:
This describes a solid harmonic to Cartesian transform.
Definition: chemistry/qc/basis/transform.h:128
void init()
This determines all of the components of the transformation.
This is a base class for a container for a component of a sparse Cartesian to solid harmonic basis fu...
Definition: chemistry/qc/basis/transform.h:41
int a() const
Returns the exponent of x.
Definition: chemistry/qc/basis/transform.h:48
int b() const
Returns the exponent of y.
Definition: chemistry/qc/basis/transform.h:50
virtual void init(int a, int b, int c, double coef, int pureindex)=0
Initialize this object.
int pureindex() const
Returns the index solid harmonic basis function.
Definition: chemistry/qc/basis/transform.h:56
double coef() const
Returns the coefficient of this component of the transformation.
Definition: chemistry/qc/basis/transform.h:58
int c() const
Returns the exponent of z.
Definition: chemistry/qc/basis/transform.h:52
int cartindex() const
Returns the index of the Cartesian basis function.
Definition: chemistry/qc/basis/transform.h:54
This iterates through the components of a SphericalTransform.
Definition: chemistry/qc/basis/transform.h:138
This is a base class for a container for a sparse Cartesian to solid harmonic basis function transfor...
Definition: chemistry/qc/basis/transform.h:75
SphericalTransform(int l, int subl=-1)
This constructs the SphericalTransform for the given Cartesian angular momentum l and solid harmonic ...
int cartindex(int i) const
Returns the Cartesian basis function index of component i.
Definition: chemistry/qc/basis/transform.h:106
int pureindex(int i) const
Returns the solid harmonic basis function index of component i.
Definition: chemistry/qc/basis/transform.h:108
int b(int i) const
Returns the Cartesian basis function's y exponent of component i.
Definition: chemistry/qc/basis/transform.h:114
int l() const
Returns the angular momentum.
Definition: chemistry/qc/basis/transform.h:118
int n() const
Returns the number of components in the transformation.
Definition: chemistry/qc/basis/transform.h:120
virtual void init()
This determines all of the components of the transformation.
void add(int a, int b, int c, double coef, int pureindex)
Adds another SphericalTransformComponent.
virtual SphericalTransformComponent * new_components()=0
This must create SphericalTransformComponent's of the appropriate specialization.
int c(int i) const
Returns the Cartesian basis function's z exponent of component i.
Definition: chemistry/qc/basis/transform.h:116
double coef(int i) const
Returns the transform coefficient of component i.
Definition: chemistry/qc/basis/transform.h:110
int a(int i) const
Returns the Cartesian basis function's x exponent of component i.
Definition: chemistry/qc/basis/transform.h:112

Generated at Thu Jan 19 2023 00:00:00 for MPQC 2.3.1 using the documentation package Doxygen 1.9.5.