MADNESS 0.10.1
CC2.h
Go to the documentation of this file.
1/*
2 * CC2.h
3 *
4 * Created on: Aug 17, 2015
5 * Author: kottmanj
6 */
7
8#ifndef CC2_H_
9#define CC2_H_
10
12#include<madness/chem/SCF.h>
13#include<madness/chem/nemo.h>
15#include<madness/chem/mp3.h>
17#include <madness/mra/mra.h>
18#include <madness/mra/vmra.h>
19#include <madness/mra/lbdeux.h>
20#include <madness/misc/ran.h>
21#include<madness/chem/TDHF.h>
23
24#include "BSHApply.h"
25
26namespace madness {
27
29public:
30
31 CC2(World& world, const CCParameters& cc_param, const TDHFParameters& tdhf_param,
32 const LowRankFunctionParameters& lrfparam,
33 const std::shared_ptr<const Nemo> nemo)
34 : world(world),
35 parameters(cc_param),
36 lrfparameters(lrfparam),
37 nemo(nemo),
38 tdhf(new TDHF(world, tdhf_param, nemo)),
41 initialize();
42 }
43
44 CC2(World& world_, const commandlineparser& parser, const std::shared_ptr<Nemo> nemo_)
45 : world(world_),
46 parameters(world_,parser),
47 lrfparameters(world_,parser),
48 nemo(nemo_),
49 tdhf(new TDHF(world, parser, nemo)),
52 initialize();
53 }
54
55 void initialize() {
56 output.section("CC2 Class has been initialized with the following parameters");
57 // set the threshholds
58 // Set Protocoll
59 output("Set Protocol 3D");
60 nemo->get_calc()->set_protocol<3>(world, parameters.thresh_3D());
61 output("Set Protocol 6D");
62 nemo->get_calc()->set_protocol<6>(world, parameters.thresh_6D());
63
66 // Make sure that k is the same in 3d and 6d functions
68 // by default SCF sets the truncate_mode to 1
71 // set initial level to 3 (important to avoid undersampling issues)
72 // the "real initial level" is then 2 since the initial level gets substracted by one if refine is true (which is the default)
79 parameters.information(world);
80 parameters.sanity_check(world);
81 }
82
83 virtual ~CC2() {}
84
85
86 double value() {
87 return value(nemo->molecule().get_all_coords());
88 }
89
90 double value(const Tensor<double>& x) {
91 solve();
92 return 0.0;
93 }
94
95 void output_calc_info_schema(const std::string model, const double& energy) const;
96
97
98 std::string name() const {return "CC2";};
99
100 static void help() {
101 print_header2("help page for CC2");
102 print("The CC2 code computes correlated ground and excited state energies:\n");
103 print(" - MP2 ground state");
104 print(" - CC2 ground and excited states");
105 print(" - ADC(2) and CIS(D) excited states\n");
106 print("You need a SCF reference calculation from the nemo program. If there no such calculation can");
107 print("be found CC2 will perform its own. If excited states are requested also a CIS calculation is ");
108 print("necessary.\n");
109 print("Note that for correlated calculations the k parameter must be chosen small, typically k=5 or k=6 ");
110 print("because the curse of dimensions make higher k extremely expensive\n");
111 print("You can print all available calculation parameters by running\n");
112 print("cc2 --print_parameters\n");
113 print("You can perform a simple MP2 calculation by running\n");
114 print("cc2 --geometry=h2o.xyz\n");
115 print("provided you have an xyz file in your directory.\n");
116
117 }
118
119 static void print_parameters() {
121 print("\ndefault parameters for the cc2 program are\n");
122 param.print("cc2","end");
123 print("\n\nthe molecular geometry must be specified in a separate block:");
125 }
126
127 virtual bool selftest() {
128 return true;
129 };
130 void
131 plot(const real_function_3d& f, const std::string& msg = "unspecified function") const {
132 plot_plane(world, f, msg);
133 output("Plotted " + msg);
134 }
135
136 /// The World
138 /// Structure holds all the parameters used in the CC2 calculation
141 /// The SCF Calculation
142 std::shared_ptr<const Nemo> nemo;
143 /// The excited state cis calculation
144 std::shared_ptr<TDHF> tdhf;
145 /// The CC Operator Class
147 /// Formated Output (same as used in CC2Potentials structure)
149 /// map Pair struct to vector
151
152 /// solve the CC2 ground state equations, returns the correlation energy
153 nlohmann::json solve();
154
155
156 std::vector<CC_vecfunction>
157 solve_ccs() const;
158
159 /// compute the MP2 correlation energy
160 static double compute_mp2_energy(const Pairs<CCPair>& pairs, const Info& info, const std::string msg="");
161 static double compute_mp2_energy(const std::vector<CCPair>& pairs, const Info& info, const std::string msg="");
162
163 /// compute the CC2 correlation energy
164 static double compute_cc2_energy(const CC_vecfunction& singles, const Pairs<CCPair>& pairs,
165 const Info& info, const std::string msg="");
166 static double compute_cc2_energy(const CC_vecfunction& singles, const std::vector<CCPair>& pairs,
167 const Info& info, const std::string msg="");
168
169 double compute_mp3(const Pairs<CCPair>& mp2pairs, const Info& info) const {
170
171 MP3 mp3(world, info);
172 double mp3_contribution=mp3.mp3_energy_contribution_macrotask_driver(mp2pairs);
173 return mp3_contribution;
174 }
175
176 double
178
179 /// solve the excited state LR-CC2 equations for a given excitation
180
181 /// @param[in] gs_doubles: the ground state doubles
182 /// @param[in] gs_singles: the ground state singles
183 /// @param[in] cis: the CIS singles
184 /// @param[in] excitation: the excitation number
185 /// @return a tuple with the excited state doubles, the excited state singles and the excitation energy
186 std::tuple<Pairs<CCPair>, CC_vecfunction, double>
187 solve_lrcc2(Pairs<CCPair>& gs_doubles, const CC_vecfunction& gs_singles, const CC_vecfunction& cis,
188 const std::size_t excitation, Info& info) const;
189
190 double
191 solve_cispd(Pairs<CCPair>& doubles, const Pairs<CCPair>& mp2_pairs, const CC_vecfunction& cis_singles);
192
193 /// convencience function to iterate the CC2 ground state singles,
194 /// makes the right call on the iterate_singles functions
195 static bool
197 // CCOPS.clear_potentials(singles);
198 info.intermediate_potentials.clear_all();
199 Pairs<CCPair> empty;
200 return iterate_singles(world, singles, CC_vecfunction(RESPONSE), doubles,
201 empty, CT_CC2, info.parameters.iter_max_3D(), info);
202 }
203
204 bool
206 MADNESS_ASSERT(singles.type == RESPONSE);
207 // CCOPS.clear_potentials(singles);
208 info.intermediate_potentials.clear_response();
209 return iterate_singles(world, singles, CC_vecfunction(UNDEFINED), mp2, x, CT_ADC2, parameters.iter_max_3D(), info);
210 }
211
212 static bool
214 MADNESS_ASSERT(cc2_s.type == PARTICLE);
215 MADNESS_ASSERT(lrcc2_s.type == RESPONSE);
216 info.intermediate_potentials.clear_response();
217 // CCOPS.clear_potentials(lrcc2_s);
218 return iterate_singles(world, lrcc2_s, cc2_s, cc2_d, lrcc2_d,
219 CT_LRCC2, info.parameters.iter_max_3D(), info);
220 }
221
222 /// convenience function to iterate the CCS Response singles,
223 /// makes the right call on the iterate_singles functions
224 bool
226 Pairs<CCPair> empty;
227 // CCOPS.clear_potentials(x);
228 info.intermediate_potentials.clear_response();
229 return iterate_singles(world, x, CC_vecfunction(PARTICLE), empty, empty, CT_LRCCS, info.parameters.iter_max_3D(), info);
230 }
231
232 /// Iterates the singles equations for CCS, CC2, LRCC2
233 /// The corresponding regulairzation tails of the doubles are updated in every iteration (therefore doubles are not marked as const)
234 /// @param[in] : singles, the singles that are iterated
235 /// @param[in] : singles2, additional set of singles for potential (in LRCC2 this are the Ground State singles)
236 /// @param[in] : gs_doubles, Ground State doubles (Needed for CC2 and LRCC2)
237 /// @param[in] : ex_doubles, Excited State doubles (Needed for LRCC2)
238 /// @param[in] : ctype: the calculation type: CCS, CC2, CC2_response_
239 /// @param[in] : maxiter: maxmial number of iterations
240 /// @param[out]: true if the overall change of the singles is below 10*donv_6D
241 static bool
242 iterate_singles(World& world, CC_vecfunction& singles, const CC_vecfunction singles2, const Pairs<CCPair>& gs_doubles,
243 const Pairs<CCPair>& ex_doubles, const CalcType ctype, const std::size_t maxiter, Info& info);
244
245 /// return the file name for singles
246 static std::string singles_name(const CalcType& ctype, const FuncType& type, int ex=-1) {
247 std::string fname=assign_name(ctype)+"_"+madness::name(type,ex);
248 return fname;
249 }
250
251 /// read singles from file or initialize new ones
252
253 /// type: PARTICLE (cc2) or RESPONSE (lrcc2)
254 /// default_to_zero: if true, initialize with zero functions, otherwise return empty vector
255 /// ex: if type is RESPONSE, the excitation number
256 static CC_vecfunction
257 initialize_singles(World&, const CalcType& ctype, const FuncType type, int ex=-1);
258
259 static CC_vecfunction
260 initialize_singles_to_zero(World& world, const CalcType& ctype, const FuncType type, const Info& info);
261
262 /// read pairs from file or initialize new ones
263 bool initialize_pairs(Pairs<CCPair>& pairs, const CCState ftype, const CalcType ctype, const CC_vecfunction& tau,
264 const CC_vecfunction& x, const size_t extitation, const Info& info) const;
265
266 /// Iterates a pair of the CC2 doubles equations
267 bool
268 iterate_pair(CCPair& pair, const CC_vecfunction& singles = CC_vecfunction(UNDEFINED)) const;
269
270 bool
272
273 static bool
274 iterate_lrcc2_pairs(World& world, const CC_vecfunction& cc2_s, const CC_vecfunction lrcc2_s,
275 Pairs<CCPair>& lrcc2_d, const Info& info);
276
280 MADNESS_ASSERT(pair.bsh_eps == CCOPS.get_epsilon(pair.i, pair.j) + ccs.omega);
281 if (pair.constant_part.is_initialized()) return false; // the CIS(D) constant part does not change because there is no singles iteration (like MP2)
282 // make screening Operator
283 real_convolution_6d Gscreen = BSHOperator<6>(world, sqrt(-2.0 * pair.bsh_eps), parameters.lo(),
284 parameters.thresh_bsh_6D());
285 Gscreen.modified() = true;
286
287 if (parameters.QtAnsatz()) pair.constant_part = CCOPS.make_constant_part_cispd_Qt(pair, ccs, &Gscreen);
288 else pair.constant_part = CCOPS.make_constant_part_cispd(pair, ccs, &Gscreen);
289 save(pair.constant_part, pair.name() + "_const");
290 return true;
291
292 }
293
295 std::cout << assign_name(pair.ctype);
298 MADNESS_ASSERT(pair.bsh_eps == CCOPS.get_epsilon(pair.i, pair.j) + ccs.omega);
299 // make screening Operator
300 real_convolution_6d Gscreen = BSHOperator<6>(world, sqrt(-2.0 * pair.bsh_eps), parameters.lo(),
301 parameters.thresh_bsh_6D());
302 Gscreen.modified() = true;
303
304 if (parameters.QtAnsatz()) pair.constant_part = CCOPS.make_constant_part_cispd_Qt(pair, ccs, &Gscreen);
305 else pair.constant_part = CCOPS.make_constant_part_cispd(pair, ccs, &Gscreen);
306 save(pair.constant_part, pair.name() + "_const");
307 return true;
308
309 }
310
311 /// forward to the other function (converting CCPair to real_function)
312 static Pairs<real_function_6d> compute_local_coupling(const std::vector<CCPair> &vpairs, const Info& info) {
313 // create new pairs structure
314 Pairs<CCPair> pairs;
315 for (auto& tmp_pair : vpairs) pairs.insert(tmp_pair.i, tmp_pair.j, tmp_pair);
316 auto ccpair2function = [](const CCPair& a) {return a.function();};
317 return compute_local_coupling(pairs.convert<real_function_6d>(pairs,ccpair2function), info);
318 };
319
320 /// compute the coupling of singles function if orbitals are localized
321
322 /// @return the coupling terms c_i = -\sum_(j\neq i) f_ij |\phi_j> (for whatever phi is)
323 static std::vector<real_function_3d> compute_local_coupling(const std::vector<real_function_3d>& singles,
324 const Info& info) {
325
326 MADNESS_CHECK_THROW(singles.size()>0,"compute_local_coupling: singles vector is empty");
327 World& world=singles.front().world();
328 auto active=Slice(info.parameters.freeze(),-1);
329 Tensor<double> Fact=info.fock(active,active);
330 for (int i=0; i<Fact.dim(0); ++i) Fact(i,i)=0.0;
331 vector_real_function_3d fock_coupling = madness::transform(world, singles, Fact);
332 return fock_coupling;
333 }
334
335 /// add the coupling terms for local MP2
336
337 /// \sum_{k\neq i} f_ki |u_kj> + \sum_{l\neq j} f_lj |u_il>
339
340
341 double solve_mp2_coupled(Pairs<CCPair> &doubles, Info& info);
342
343 bool check_core_valence_separation(const Tensor<double>& fmat) const;
344
345 /// make sure the orbitals are block diagonalized
346
347 /// changes the orbitals in member variable nemo
348 /// will throw if the fock matrix is not block diagonal
349 /// @return the new fock matrix
351};
352
353
354} /* namespace madness */
355
356#endif /* CC2_H_ */
long dim(int i) const
Returns the size of dimension i.
Definition basetensor.h:147
double solve_cispd(Pairs< CCPair > &doubles, const Pairs< CCPair > &mp2_pairs, const CC_vecfunction &cis_singles)
Definition CC2.cc:683
CCMessenger & output
Formated Output (same as used in CC2Potentials structure).
Definition CC2.h:148
static CC_vecfunction initialize_singles_to_zero(World &world, const CalcType &ctype, const FuncType type, const Info &info)
Definition CC2.cc:1453
Tensor< double > enforce_core_valence_separation(const Tensor< double > &fmat)
make sure the orbitals are block diagonalized
Definition CC2.cc:365
bool iterate_ccs_singles(CC_vecfunction &x, Info &info) const
Definition CC2.h:225
static CC_vecfunction initialize_singles(World &, const CalcType &ctype, const FuncType type, int ex=-1)
read singles from file or initialize new ones
Definition CC2.cc:1436
static double compute_mp2_energy(const Pairs< CCPair > &pairs, const Info &info, const std::string msg="")
compute the MP2 correlation energy
Definition CC2.cc:864
CC2(World &world, const CCParameters &cc_param, const TDHFParameters &tdhf_param, const LowRankFunctionParameters &lrfparam, const std::shared_ptr< const Nemo > nemo)
Definition CC2.h:31
static std::string singles_name(const CalcType &ctype, const FuncType &type, int ex=-1)
return the file name for singles
Definition CC2.h:246
virtual bool selftest()
Definition CC2.h:127
double solve_mp2_coupled(Pairs< CCPair > &doubles, Info &info)
Definition CC2.cc:430
void output_calc_info_schema(const std::string model, const double &energy) const
Definition CC2.cc:345
World & world
The World.
Definition CC2.h:137
static void help()
Definition CC2.h:100
CCParameters parameters
Structure holds all the parameters used in the CC2 calculation.
Definition CC2.h:139
static bool iterate_cc2_singles(World &world, CC_vecfunction &singles, Pairs< CCPair > &doubles, Info &info)
Definition CC2.h:196
std::tuple< Pairs< CCPair >, CC_vecfunction, double > solve_lrcc2(Pairs< CCPair > &gs_doubles, const CC_vecfunction &gs_singles, const CC_vecfunction &cis, const std::size_t excitation, Info &info) const
solve the excited state LR-CC2 equations for a given excitation
Definition CC2.cc:1012
bool update_constant_part_adc2(const CC_vecfunction &ccs, CCPair &pair)
Definition CC2.h:294
bool update_constant_part_cispd(const CC_vecfunction &ccs, CCPair &pair)
Definition CC2.h:277
double compute_mp3(const Pairs< CCPair > &mp2pairs, const Info &info) const
Definition CC2.h:169
CC2(World &world_, const commandlineparser &parser, const std::shared_ptr< Nemo > nemo_)
Definition CC2.h:44
bool iterate_adc2_singles(Pairs< CCPair > &mp2, CC_vecfunction &singles, Pairs< CCPair > &x, Info &info)
Definition CC2.h:205
static void print_parameters()
Definition CC2.h:119
static Pairs< real_function_6d > compute_local_coupling(const std::vector< CCPair > &vpairs, const Info &info)
forward to the other function (converting CCPair to real_function)
Definition CC2.h:312
static double compute_cc2_energy(const CC_vecfunction &singles, const Pairs< CCPair > &pairs, const Info &info, const std::string msg="")
compute the CC2 correlation energy
Definition CC2.cc:833
double value()
Definition CC2.h:86
nlohmann::json solve()
solve the CC2 ground state equations, returns the correlation energy
Definition CC2.cc:23
double solve_cc2(CC_vecfunction &tau, Pairs< CCPair > &u, Info &info) const
Definition CC2.cc:875
std::vector< CC_vecfunction > solve_ccs() const
Definition CC2.cc:415
virtual ~CC2()
Definition CC2.h:83
PairVectorMap triangular_map
map Pair struct to vector
Definition CC2.h:150
static bool iterate_singles(World &world, CC_vecfunction &singles, const CC_vecfunction singles2, const Pairs< CCPair > &gs_doubles, const Pairs< CCPair > &ex_doubles, const CalcType ctype, const std::size_t maxiter, Info &info)
Definition CC2.cc:1213
static bool iterate_lrcc2_pairs(World &world, const CC_vecfunction &cc2_s, const CC_vecfunction lrcc2_s, Pairs< CCPair > &lrcc2_d, const Info &info)
Definition CC2.cc:738
void initialize()
Definition CC2.h:55
static std::vector< real_function_3d > compute_local_coupling(const std::vector< real_function_3d > &singles, const Info &info)
compute the coupling of singles function if orbitals are localized
Definition CC2.h:323
CCPotentials CCOPS
The CC Operator Class.
Definition CC2.h:146
bool check_core_valence_separation(const Tensor< double > &fmat) const
Definition CC2.cc:357
static bool iterate_lrcc2_singles(World &world, const CC_vecfunction &cc2_s, Pairs< CCPair > &cc2_d, CC_vecfunction &lrcc2_s, Pairs< CCPair > lrcc2_d, Info &info)
Definition CC2.h:213
double value(const Tensor< double > &x)
Should return the value of the objective function.
Definition CC2.h:90
bool iterate_pair(CCPair &pair, const CC_vecfunction &singles=CC_vecfunction(UNDEFINED)) const
Iterates a pair of the CC2 doubles equations.
Definition CC2.cc:1106
LowRankFunctionParameters lrfparameters
Definition CC2.h:140
bool iterate_adc2_pairs(Pairs< CCPair > &cispd, const CC_vecfunction &ccs)
Definition CC2.cc:721
std::shared_ptr< const Nemo > nemo
The SCF Calculation.
Definition CC2.h:142
std::shared_ptr< TDHF > tdhf
The excited state cis calculation.
Definition CC2.h:144
std::string name() const
Definition CC2.h:98
void plot(const real_function_3d &f, const std::string &msg="unspecified function") const
Definition CC2.h:131
bool initialize_pairs(Pairs< CCPair > &pairs, const CCState ftype, const CalcType ctype, const CC_vecfunction &tau, const CC_vecfunction &x, const size_t extitation, const Info &info) const
read pairs from file or initialize new ones
Definition CC2.cc:1465
Definition CCStructures.h:995
std::string name() const
Definition CCStructures.h:1156
size_t i
Definition CCStructures.h:1012
real_function_6d constant_part
the constant part
Definition CCStructures.h:1140
size_t j
Definition CCStructures.h:1013
CCState type
Definition CCStructures.h:1010
double bsh_eps
Definition CCStructures.h:1146
CalcType ctype
Definition CCStructures.h:1011
Class which calculates all types of CC2 Potentials.
Definition CCPotentials.h:20
static int get_k()
Returns the default wavelet order.
Definition funcdefaults.h:170
static void set_truncate_mode(int value)
Sets the default truncation mode.
Definition funcdefaults.h:242
static void set_thresh(double value)
Sets the default threshold.
Definition funcdefaults.h:190
static void set_special_level(int value)
Existing functions are unaffected.
Definition funcdefaults.h:213
static void set_k(int value)
Sets the default wavelet order.
Definition funcdefaults.h:177
static void set_initial_level(int value)
Sets the default initial projection level.
Definition funcdefaults.h:207
static int set_length_scale(const double lo, const size_t k=get_k())
adapt the special level to resolve the smallest length scale
Definition funcdefaults.h:343
bool is_initialized() const
Returns true if the function is initialized.
Definition mra.h:169
Definition mp3.h:21
double mp3_energy_contribution_macrotask_driver(const Pairs< CCPair > &mp2pairs) const
compute the MP3 energy contribution, macrotask version
Definition mp3.cc:943
static void print_parameters()
Definition molecule.cc:122
class implementing properties of QC models
Definition QCPropertyInterface.h:11
bool & modified()
Definition operator.h:213
A slice defines a sub-range or patch of a dimension.
Definition slice.h:103
Definition TDHF.h:219
A tensor is a multidimensional array.
Definition tensor.h:313
A parallel world class.
Definition world.h:134
double(* energy)()
Definition derivatives.cc:58
const int maxiter
Definition gygi_soltion.cc:68
static double u(double r, double c)
Definition he.cc:20
Implements (2nd generation) static load/data balancing for functions.
#define MADNESS_ASSERT(condition)
Assert a condition that should be free of side-effects since in release builds this might be a no-op.
Definition madness_exception.h:134
#define MADNESS_CHECK_THROW(condition, msg)
Check a condition — even in a release build the condition is always evaluated so it can have side eff...
Definition madness_exception.h:207
Main include file for MADNESS and defines Function interface.
Runtime details on the configuration and version of MADNESS.
Definition madness.h:69
Namespace for all elements and tools of MADNESS.
Definition DFConvergence.h:9
CalcType
Calculation Types used by CC2.
Definition CCParameters.h:14
@ CT_CC2
Definition CCParameters.h:15
@ CT_LRCC2
Definition CCParameters.h:15
@ CT_LRCCS
Definition CCParameters.h:15
@ CT_CISPD
Definition CCParameters.h:15
@ CT_ADC2
Definition CCParameters.h:15
void print_header2(const std::string &s)
medium section heading
Definition print.cc:54
CCState
Type of Pairs used by CC_Pair2 class.
Definition CCStructures.h:27
@ EXCITED_STATE
Definition CCStructures.h:28
FuncType
Definition ccpairfunction.h:26
@ RESPONSE
Definition ccpairfunction.h:26
@ UNDEFINED
Definition ccpairfunction.h:26
@ PARTICLE
Definition ccpairfunction.h:26
std::vector< Function< TENSOR_RESULT_TYPE(T, R), NDIM > > transform(World &world, const std::vector< Function< T, NDIM > > &v, const Tensor< R > &c, bool fence=true)
Transforms a vector of functions according to new[i] = sum[j] old[j]*c[j,i].
Definition vmra.h:807
std::vector< real_function_3d > vector_real_function_3d
Definition functypedefs.h:94
void plot_plane(World &world, const Function< double, NDIM > &function, const std::string name)
Definition funcplot.h:625
Function< double, 6 > real_function_6d
Definition functypedefs.h:83
NDIM & f
Definition mra.h:2817
Function< double, 3 > real_function_3d
Definition functypedefs.h:80
void print(const T &t, Ts &&... ts)
Print items to std::cout (items separated by spaces) and terminate with a new line.
Definition print.h:232
static SeparatedConvolution< double, NDIM > BSHOperator(World &world, double mu, double lo, double eps, const std::array< LatticeRange, NDIM > &lattice_ranges=FunctionDefaults< NDIM >::get_bc().lattice_range(), int k=FunctionDefaults< NDIM >::get_k())
Factory function generating separated kernel for convolution with BSH kernel in general NDIM.
Definition operator.h:2053
SeparatedConvolution< double, 6 > real_convolution_6d
Definition functypedefs.h:139
std::string assign_name(const CCState &input)
Assigns strings to enums for formated output.
Definition CCStructures.cc:379
std::string name(const FuncType &type, const int ex=-1)
Definition ccpairfunction.h:28
void save(const Function< T, NDIM > &f, const std::string name)
Definition mra.h:3175
static const double a
Definition nonlinschro.cc:118
Implementation of Krylov-subspace nonlinear equation solver.
Implements most functionality of separated operators.
Definition CCStructures.h:86
Definition CCParameters.h:20
A helper structure which holds a map of functions.
Definition CCStructures.h:334
FuncType type
Definition CCStructures.h:473
double omega
Definition CCStructures.h:474
POD holding some basic functions and some intermediates for the CC2 calculation.
Definition CCStructures.h:919
Definition lowrankfunction.h:22
The interface to be provided by functions to be optimized.
Definition solvers.h:176
Definition CCStructures.h:206
Definition CCStructures.h:246
Pairs< R > convert(const Pairs< T > arg, const opT op) const
convert Pairs<T> to another type
Definition CCStructures.h:255
void insert(int i, int j, const T &pair)
Definition CCStructures.h:296
the TDHF parameter class
Definition TDHF.h:23
very simple command line parser
Definition commandlineparser.h:28
InputParameters param
Definition tdse.cc:203
Defines operations on vectors of Functions.