MPQC  2.3.1
obint.h
1 //
2 // obint.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 #ifndef _chemistry_qc_basis_obint_h
29 #define _chemistry_qc_basis_obint_h
30 
31 #ifdef __GNUC__
32 #pragma interface
33 #endif
34 
35 #include <util/ref/ref.h>
36 #include <util/state/state.h>
37 #include <math/scmat/matrix.h>
38 #include <math/scmat/elemop.h>
39 
40 #include <chemistry/qc/basis/gaussbas.h>
41 #include <chemistry/qc/basis/dercent.h>
42 
43 namespace sc {
44 
45 class Integral;
46 
47 // //////////////////////////////////////////////////////////////////////////
48 
50 {
51  public:
54 
55  double position[3];
56  double vector[3];
57 
58  void set_position(double*);
59  void set_vector(double*);
60 };
61 
62 
63 class DipoleData: public RefCount
64 {
65  public:
66  double origin[3];
67 
68  DipoleData(double *d) {origin[0]=d[0]; origin[1]=d[1]; origin[2]=d[2];}
69  DipoleData() {origin[0]=origin[1]=origin[2]=0.0;}
70  ~DipoleData();
71  void set_origin(double*);
72 };
73 
74 
76 {
77  private:
78  int ncharges_;
79  const double *charges_;
80  const double *const*positions_;
81  double *alloced_charges_;
82  double **alloced_positions_;
83 
84  public:
85  // If copy_data is 0, the passed positions and charges will
86  // be stored (but not freed).
87  PointChargeData(int ncharge,
88  const double *const*positions, const double *charges,
89  int copy_data = 0);
90  ~PointChargeData();
91 
92  int ncharges() const { return ncharges_; }
93  const double *charges() const { return charges_; }
94  const double *const*positions() const { return positions_; }
95 };
96 
97 
100 class OneBodyInt : public RefCount {
101  protected:
102  // this is who created me
103  Integral *integral_;
104 
107 
108  double *buffer_;
109 
110  OneBodyInt(Integral *integral,
111  const Ref<GaussianBasisSet>&b1,
112  const Ref<GaussianBasisSet>&b2 = 0);
113 
114  public:
115  virtual ~OneBodyInt();
116 
118  int nbasis() const;
119 
121  int nbasis1() const;
123  int nbasis2() const;
124 
126  int nshell() const;
127 
129  int nshell1() const;
131  int nshell2() const;
132 
135 
140 
142  const double * buffer() const;
143 
146  virtual void compute_shell(int,int) = 0;
147 
150  virtual void reinitialize();
151 
154  virtual bool cloneable();
155 
158  virtual Ref<OneBodyInt> clone();
159 
160  Integral *integral() const { return integral_; }
161 };
162 
163 // //////////////////////////////////////////////////////////////////////////
164 
168  protected:
169  // this is who created me
170  Integral *integral_;
171 
173 
174  double *buffer_;
175 
176  OneBodyOneCenterInt(Integral *integral,
177  const Ref<GaussianBasisSet>&b1);
178 
179  public:
180  virtual ~OneBodyOneCenterInt();
181 
183  int nbasis() const;
184 
186  int nbasis1() const;
187 
189  int nshell() const;
190 
192  int nshell1() const;
193 
196 
199 
201  const double * buffer() const;
202 
205  virtual void compute_shell(int) = 0;
206 
209  virtual void reinitialize();
210 
213  virtual bool cloneable();
214 
218 
219  Integral *integral() const { return integral_; }
220 };
221 
222 // //////////////////////////////////////////////////////////////////////////
223 
225  Ref<OneBodyInt> ob_;
226  int jsh_;
227  public:
229  int sh2 = 0);
230  void compute_shell(int);
231 };
232 
233 // //////////////////////////////////////////////////////////////////////////
234 
236  private:
237  const double * buf;
238  double scale_;
239 
240  int e12;
241 
242  int index;
243 
244  int ioffset;
245  int joffset;
246 
247  int iend;
248  int jend;
249 
250  int icur;
251  int jcur;
252 
253  public:
254  ShellPairIter();
255  ~ShellPairIter();
256 
257  void init(const double * buffer, int ishell, int jshell,
258  int ioff, int joff, int nfunci, int nfuncj, int redund=0,
259  double scale=1.0);
260 
261  void start() { icur=jcur=index=0; }
262  int ready() const { return (icur < iend); }
263 
264  void next() {
265  if (jcur < ((e12)?(icur):((jend)-1))) {
266  index++;
267  jcur++;
268  return;
269  }
270 
271  jcur=0;
272  icur++;
273 
274  index = icur*jend;
275  }
276 
277  int current_i() const { return icur; }
278  int current_j() const { return jcur; }
279 
280  int i() const { return icur+ioffset; }
281  int j() const { return jcur+joffset; }
282 
283  int nint() const { return iend*jend; }
284 
285  double val() const { return buf[index]*scale_; }
286 };
287 
288 // //////////////////////////////////////////////////////////////////////////
289 
290 class OneBodyIntIter : public RefCount {
291  protected:
292  Ref<OneBodyInt> obi; // help me obi wan
293  ShellPairIter spi;
294 
295  int redund;
296 
297  int istart;
298  int jstart;
299 
300  int iend;
301  int jend;
302 
303  int icur;
304  int jcur;
305 
306  int ij;
307 
308  public:
309  OneBodyIntIter();
311  virtual ~OneBodyIntIter();
312 
313  virtual void start(int ist=0, int jst=0, int ien=0, int jen=0);
314  virtual void next();
315 
316  int ready() const { return (icur < iend); }
317 
318  int ishell() const { return icur; }
319  int jshell() const { return jcur; }
320 
321  int ijshell() const { return ij; }
322 
323  int redundant() const { return redund; }
324  void set_redundant(int i) { redund=i; }
325 
326  virtual double scale() const;
327 
328  Ref<OneBodyInt> one_body_int() { return obi; }
329 
330  ShellPairIter& current_pair();
331 
332  virtual bool cloneable();
333  virtual Ref<OneBodyIntIter> clone();
334 };
335 
336 
337 
338 // //////////////////////////////////////////////////////////////////////////
339 
340 class OneBodyIntOp: public SCElementOp {
341  protected:
342  Ref<OneBodyIntIter> iter;
343 
344  public:
347  virtual ~OneBodyIntOp();
348 
349  void process(SCMatrixBlockIter&);
351  void process_spec_ltri(SCMatrixLTriBlock*);
352  void process_spec_rectsub(SCMatrixRectSubBlock*);
353  void process_spec_ltrisub(SCMatrixLTriSubBlock*);
354 
355  bool cloneable();
357 
358  int has_side_effects();
359 };
360 
362  private:
363  Ref<OneBodyIntIter> iter;
364 
365  public:
368  virtual ~OneBody3IntOp();
369 
370  void process(SCMatrixBlockIter&,
373  void process_spec_rect(SCMatrixRectBlock*,
376  void process_spec_ltri(SCMatrixLTriBlock*,
379 
380  int has_side_effects();
381  int has_side_effects_in_arg1();
382  int has_side_effects_in_arg2();
383 
384 };
385 
386 // //////////////////////////////////////////////////////////////////////////
387 
390 class OneBodyDerivInt : public RefCount {
391  protected:
392  // this is who created me
393  Integral *integral_;
394 
397 
398  double *buffer_;
399 
400  public:
403  const Ref<GaussianBasisSet>&b1,
404  const Ref<GaussianBasisSet>&b2);
405  virtual ~OneBodyDerivInt();
406 
408  int nbasis() const;
410  int nbasis1() const;
412  int nbasis2() const;
413 
415  int nshell() const;
417  int nshell1() const;
419  int nshell2() const;
420 
427 
430  const double * buffer() const;
431 
434  virtual void compute_shell(int ish, int jsh, DerivCenters&) = 0;
437  virtual void compute_shell(int ish, int jsh, int center) = 0;
438 };
439 
440 // //////////////////////////////////////////////////////////////////////////
441 
445  protected:
446  // this is who created me
447  Integral *integral_;
448 
450 
451  double *buffer_;
452 
453  public:
455  virtual ~OneBodyOneCenterDerivInt();
456 
458  int nbasis() const;
460  int nbasis1() const;
461 
463  int nshell() const;
465  int nshell1() const;
466 
471 
474  const double * buffer() const;
475 
478  virtual void compute_shell(int ish, DerivCenters&) = 0;
481  virtual void compute_shell(int ish, int center) = 0;
482 };
483 
484 }
485 
486 #endif
487 
488 // Local Variables:
489 // mode: c++
490 // c-file-style: "ETS"
491 // End:

Generated at Mon Aug 12 2013 12:47:23 for MPQC 2.3.1 using the documentation package Doxygen 1.8.3.1.