TBTK
EnergyResolvedProperty.h
Go to the documentation of this file.
1 /* Copyright 2018 Kristofer Bj√∂rnson
2  *
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
23 #ifndef COM_DAFER45_TBTK_PROPERTY_ENERGY_RESOLVED_PROPERTY
24 #define COM_DAFER45_TBTK_PROPERTY_ENERGY_RESOLVED_PROPERTY
25 
26 #include "TBTK/Property/AbstractProperty.h"
27 #include "TBTK/TBTKMacros.h"
28 
29 #include <complex>
30 #include <vector>
31 
32 namespace TBTK{
33 namespace Property{
34 
36 template<typename DataType>
37 class EnergyResolvedProperty : public AbstractProperty<DataType>{
38 public:
40  enum class EnergyType{Real, FermionicMatsubara, BosonicMatsubara};
41 
44 
56  const IndexTree &indexTree,
57  double lowerBound,
58  double upperBound,
59  unsigned int resolution
60  );
61 
76  const IndexTree &indexTree,
77  double lowerBound,
78  double upperBound,
79  unsigned int resolution,
80  const DataType *data
81  );
82 
94  EnergyType energyType,
95  const IndexTree &indexTree,
96  int lowerMatsubaraEnergyIndex,
97  int upperMatsubaraEnergtIndex,
98  double fundamentalMatsubaraEnergy
99  );
100 
115  EnergyType energyType,
116  const IndexTree &indexTree,
117  int lowerMatsubaraEnergyIndex,
118  int upperMatsubaraEnergtIndex,
119  double fundamentalMatsubaraEnergy,
120  const DataType *data
121  );
122 
129  const std::string &serialization,
130  Serializable::Mode mode
131  );
132 
133  /*** Get energy type.
134  *
135  * @return The EnergyType. */
136  EnergyType getEnergyType() const;
137 
141  double getLowerBound() const;
142 
146  double getUpperBound() const;
147 
152  unsigned int getResolution() const;
153 
159  double getEnergy(unsigned int n) const;
160 
165  int getLowerMatsubaraEnergyIndex() const;
166 
172  int getUpperMatsubaraEnergyIndex() const;
173 
177  unsigned int getNumMatsubaraEnergies() const;
178 
181  double getFundamentalMatsubaraEnergy() const;
182 
186  double getLowerMatsubaraEnergy() const;
187 
191  double getUpperMatsubaraEnergy() const;
192 
194  std::complex<double> getMatsubaraEnergy(unsigned int n) const;
195 
197  virtual std::string serialize(Serializable::Mode mode) const;
198 private:
200  EnergyType energyType;
201 
202  class RealEnergy{
203  public:
205  double lowerBound;
206 
208  double upperBound;
209 
211  unsigned int resolution;
212  };
213 
214  class MatsubaraEnergy{
215  public:
217  int lowerMatsubaraEnergyIndex;
218 
220  int numMatsubaraEnergies;
221 
223  double fundamentalMatsubaraEnergy;
224  };
225 
227  union EnergyDescriptor{
228  RealEnergy realEnergy;
229  MatsubaraEnergy matsubaraEnergy;
230  };
231 
233  EnergyDescriptor descriptor;
234 };
235 
236 template<typename DataType>
238 }
239 
240 template<typename DataType>
242  const IndexTree &indexTree,
243  double lowerBound,
244  double upperBound,
245  unsigned int resolution
246 ) :
247  AbstractProperty<DataType>(indexTree, resolution)
248 {
249  TBTKAssert(
250  lowerBound <= upperBound,
251  "EnergyResolvedProperty::EnergyResolvedProperty()",
252  "Invalid energy bounds. The 'lowerBound=" << lowerBound << "'"
253  " must be less or equal to the 'upperBound=" << upperBound
254  << "'.",
255  ""
256  );
257  TBTKAssert(
258  resolution > 0,
259  "EnergyResolvedProperty::EnergyResolvedProperty()",
260  "The 'resolution' must be larger than 0.",
261  ""
262  );
263 
264  energyType = EnergyType::Real;
265  descriptor.realEnergy.lowerBound = lowerBound;
266  descriptor.realEnergy.upperBound = upperBound;
267  descriptor.realEnergy.resolution = resolution;
268 }
269 
270 template<typename DataType>
272  const IndexTree &indexTree,
273  double lowerBound,
274  double upperBound,
275  unsigned int resolution,
276  const DataType *data
277 ) :
278  AbstractProperty<DataType>(indexTree, resolution, data)
279 {
280  TBTKAssert(
281  lowerBound < upperBound,
282  "EnergyResolvedProperty::EnergyResolvedProperty()",
283  "Invalid energy bounds. The 'lowerBound=" << lowerBound << "'"
284  " must be smaller than the 'upperBound=" << upperBound << "'.",
285  ""
286  );
287  TBTKAssert(
288  resolution > 0,
289  "EnergyResolvedProperty::EnergyResolvedProperty()",
290  "The 'resolution' must be larger than 0.",
291  ""
292  );
293 
294  energyType = EnergyType::Real;
295  descriptor.realEnergy.lowerBound = lowerBound;
296  descriptor.realEnergy.upperBound = upperBound;
297  descriptor.realEnergy.resolution = resolution;
298 }
299 
300 template<typename DataType>
302  EnergyType energyType,
303  const IndexTree &indexTree,
304  int lowerMatsubaraEnergyIndex,
305  int upperMatsubaraEnergyIndex,
306  double fundamentalMatsubaraEnergy
307 ) :
308  AbstractProperty<DataType>(
309  indexTree,
310  (upperMatsubaraEnergyIndex-lowerMatsubaraEnergyIndex)/2 + 1
311  )
312 {
313  TBTKAssert(
314  lowerMatsubaraEnergyIndex <= upperMatsubaraEnergyIndex,
315  "EnergyResolvedProperty::EnergyResolvedProperty()",
316  "Invalid Matsubara energy bounds. The"
317  " 'lowerMatsubaraEnergyIndex=" << lowerMatsubaraEnergyIndex
318  << "' must be less or equal to the 'upperMatsubaraEnergyIndex="
319  << upperMatsubaraEnergyIndex << "'.",
320  ""
321  );
322  TBTKAssert(
323  fundamentalMatsubaraEnergy > 0,
324  "EnergyResolvedProperty::energyResolvedProperty()",
325  "The 'fundamentalMatsubaraEnergy' must be larger than 0.",
326  ""
327  );
328 
329  switch(energyType){
330  case EnergyType::FermionicMatsubara:
331  TBTKAssert(
332  abs(lowerMatsubaraEnergyIndex%2) == 1,
333  "EnergyResolvedProperty::EnergyResolvedProperty()",
334  "The 'lowerMatsubaraEnergyIndex="
335  << lowerMatsubaraEnergyIndex << "' must be odd for"
336  << " EnergyType::FermionicMatsubara.",
337  ""
338  );
339  TBTKAssert(
340  abs(upperMatsubaraEnergyIndex%2) == 1,
341  "EnergyResolvedProperty::EnergyResolvedProperty()",
342  "The 'upperMatsubaraEnergyIndex="
343  << upperMatsubaraEnergyIndex << "' must be odd for"
344  << " EnergyType::FermionicMatsubara.",
345  ""
346  );
347 
348  this->energyType = energyType;
349  descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
350  = lowerMatsubaraEnergyIndex;
351  descriptor.matsubaraEnergy.numMatsubaraEnergies = (
352  upperMatsubaraEnergyIndex-lowerMatsubaraEnergyIndex)/2
353  + 1;
354  descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
355  = fundamentalMatsubaraEnergy;
356 
357  break;
358  case EnergyType::BosonicMatsubara:
359  TBTKAssert(
360  lowerMatsubaraEnergyIndex%2 == 0,
361  "EnergyResolvedProperty::EnergyResolvedProperty()",
362  "The 'lowerMatsubaraEnergyIndex="
363  << lowerMatsubaraEnergyIndex << "' must be even for"
364  << " EnergyType::BosonicMatsubara.",
365  ""
366  );
367  TBTKAssert(
368  upperMatsubaraEnergyIndex%2 == 0,
369  "EnergyResolvedProperty::EnergyResolvedProperty()",
370  "The 'upperMatsubaraEnergyIndex="
371  << upperMatsubaraEnergyIndex << "' must be even for"
372  << " EnergyType::BosonicMatsubara.",
373  ""
374  );
375 
376  this->energyType = energyType;
377  descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
378  = lowerMatsubaraEnergyIndex;
379  descriptor.matsubaraEnergy.numMatsubaraEnergies = (
380  upperMatsubaraEnergyIndex-lowerMatsubaraEnergyIndex)/2
381  + 1;
382  descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
383  = fundamentalMatsubaraEnergy;
384 
385  break;
386  default:
387  TBTKExit(
388  "EnergyResolvedProperty::EnergyResolvedProperty()",
389  "The 'energyType' must be"
390  " EnergyType::FermionicMatsubara or"
391  " EnergyType::BosonicMatsubara.",
392  ""
393  );
394  }
395 }
396 
397 template<typename DataType>
399  EnergyType energyType,
400  const IndexTree &indexTree,
401  int lowerMatsubaraEnergyIndex,
402  int upperMatsubaraEnergyIndex,
403  double fundamentalMatsubaraEnergy,
404  const DataType *data
405 ) :
406  AbstractProperty<DataType>(
407  indexTree,
408  (upperMatsubaraEnergyIndex-lowerMatsubaraEnergyIndex)/2 + 1,
409  data
410  )
411 {
412  TBTKAssert(
413  lowerMatsubaraEnergyIndex <= upperMatsubaraEnergyIndex,
414  "EnergyResolvedProperty::EnergyResolvedProperty()",
415  "Invalid Matsubara energy bounds. The"
416  " 'lowerMatsubaraEnergyIndex=" << lowerMatsubaraEnergyIndex
417  << "' must be less or equal to the 'upperMatsubaraEnergyIndex="
418  << upperMatsubaraEnergyIndex << "'.",
419  ""
420  );
421  TBTKAssert(
422  fundamentalMatsubaraEnergy > 0,
423  "EnergyResolvedProperty::energyResolvedProperty()",
424  "The 'fundamentalMatsubaraEnergy' must be larger than 0.",
425  ""
426  );
427 
428  switch(energyType){
429  case EnergyType::FermionicMatsubara:
430  TBTKAssert(
431  abs(lowerMatsubaraEnergyIndex%2) == 1,
432  "EnergyResolvedProperty::EnergyResolvedProperty()",
433  "The 'lowerMatsubaraEnergyIndex="
434  << lowerMatsubaraEnergyIndex << "' must be odd for"
435  << " EnergyType::FermionicMatsubara.",
436  ""
437  );
438  TBTKAssert(
439  abs(upperMatsubaraEnergyIndex%2) == 1,
440  "EnergyResolvedProperty::EnergyResolvedProperty()",
441  "The 'uppererMatsubaraEnergyIndex="
442  << upperMatsubaraEnergyIndex << "' must be odd for"
443  << " EnergyType::FermionicMatsubara.",
444  ""
445  );
446 
447  this->energyType = energyType;
448  descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
449  = lowerMatsubaraEnergyIndex;
450  descriptor.matsubaraEnergy.numMatsubaraEnergies = (
451  upperMatsubaraEnergyIndex-lowerMatsubaraEnergyIndex)/2
452  + 1;
453  descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
454  = fundamentalMatsubaraEnergy;
455 
456  break;
457  case EnergyType::BosonicMatsubara:
458  TBTKAssert(
459  lowerMatsubaraEnergyIndex%2 == 0,
460  "EnergyResolvedProperty::EnergyResolvedProperty()",
461  "The 'lowerMatsubaraEnergyIndex="
462  << lowerMatsubaraEnergyIndex << "' must be even for"
463  << " EnergyType::BosonicMatsubara.",
464  ""
465  );
466  TBTKAssert(
467  upperMatsubaraEnergyIndex%2 == 0,
468  "EnergyResolvedProperty::EnergyResolvedProperty()",
469  "The 'uppererMatsubaraEnergyIndex="
470  << upperMatsubaraEnergyIndex << "' must be even for"
471  << " EnergyType::BosonicMatsubara.",
472  ""
473  );
474 
475  this->energyType = energyType;
476  descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
477  = lowerMatsubaraEnergyIndex;
478  descriptor.matsubaraEnergy.numMatsubaraEnergies = (
479  upperMatsubaraEnergyIndex-lowerMatsubaraEnergyIndex)/2
480  + 1;
481  descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
482  = fundamentalMatsubaraEnergy;
483 
484  break;
485  default:
486  TBTKExit(
487  "EnergyResolvedProperty::EnergyResolvedProperty()",
488  "The 'energyType' must be"
489  " EnergyType::FermionicMatsubara or"
490  " EnergyType::BosonicMatsubara.",
491  ""
492  );
493  }
494 }
495 
496 template<typename DataType>
498  const std::string &serialization,
499  Serializable::Mode mode
500 ) :
501  AbstractProperty<DataType>(
503  serialization,
504  mode,
505  "abstractProperty"
506  ),
507  mode
508  )
509 {
510  TBTKAssert(
511  Serializable::validate(serialization, "EnergyResolvedProperty", mode),
512  "Property::EnergyResolvedProperty::EnergyResolvedProperty()",
513  "Unable to parse string as EnergyResolvedProperty '"
514  << serialization << "'.",
515  ""
516  );
517 
518  switch(mode){
519  case Serializable::Mode::JSON:
520  try{
521  nlohmann::json j = nlohmann::json::parse(serialization);
522  std::string et = j.at("energyType").get<std::string>();
523  if(et.compare("Real") == 0){
524  energyType = EnergyType::Real;
525  descriptor.realEnergy.lowerBound
526  = j.at("lowerBound").get<double>();
527  descriptor.realEnergy.upperBound
528  = j.at("upperBound").get<double>();
529  descriptor.realEnergy.resolution
530  = j.at("resolution").get<double>();
531  }
532  else if(et.compare("FermionicMatsubara") == 0){
533  energyType = EnergyType::FermionicMatsubara;
534  descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
535  = j.at("lowerMatsubaraEnergyIndex");
536  descriptor.matsubaraEnergy.numMatsubaraEnergies
537  = j.at("numMatsubaraEnergies");
538  descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
539  = j.at("fundamentalMatsubaraEnergy");
540  }
541  else if(et.compare("BosonicMatsubara") == 0){
542  energyType = EnergyType::BosonicMatsubara;
543  descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
544  = j.at("lowerMatsubaraEnergyIndex");
545  descriptor.matsubaraEnergy.numMatsubaraEnergies
546  = j.at("numMatsubaraEnergies");
547  descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
548  = j.at("fundamentalMatsubaraEnergy");
549  }
550  }
551  catch(nlohmann::json::exception &e){
552  TBTKExit(
553  "Proerty::EnergyResolvedProperty::EnergyResolvedProperty()",
554  "Unable to parse string as"
555  << " EnergyResolvedProperty '" << serialization
556  << "'.",
557  ""
558  );
559  }
560 
561  break;
562  default:
563  TBTKExit(
564  "Property::EnergyResolvedProperty::EnergyResolvedProperty()",
565  "Only Serializable::Mode::JSON is supported yet.",
566  ""
567  );
568  }
569 }
570 
571 template<typename DataType>
574  return energyType;
575 }
576 
577 template<typename DataType>
579  TBTKAssert(
580  energyType == EnergyType::Real,
581  "GreensFunction::getLowerBound()",
582  "The Property is not of the type EnergyType::Real.",
583  ""
584  );
585 
586  return descriptor.realEnergy.lowerBound;
587 }
588 
589 template<typename DataType>
591  TBTKAssert(
592  energyType == EnergyType::Real,
593  "GreensFunction::getUpperBound()",
594  "The Property is not of the type EnergyType::Real.",
595  ""
596  );
597 
598  return descriptor.realEnergy.upperBound;
599 }
600 
601 template<typename DataType>
603  TBTKAssert(
604  energyType == EnergyType::Real,
605  "GreensFunction::getResolution()",
606  "The Property is not of the type EnergyType::Real.",
607  ""
608  );
609 
610  return descriptor.realEnergy.resolution;
611 }
612 
613 template<typename DataType>
615  unsigned int n
616 ) const{
617  TBTKAssert(
618  energyType == EnergyType::Real,
619  "GreensFunction::getEnergy()",
620  "The Property is not of the type EnergyType::Real.",
621  ""
622  );
623 
624  double dE;
625  if(descriptor.realEnergy.resolution == 1)
626  dE = 0;
627  else
628  dE = (
629  descriptor.realEnergy.upperBound
630  - descriptor.realEnergy.lowerBound
631  )/(descriptor.realEnergy.resolution - 1);
632 
633  return descriptor.realEnergy.lowerBound + ((int)n)*dE;
634 }
635 
636 template<typename DataType>
638 ) const{
639  TBTKAssert(
640  energyType == EnergyType::FermionicMatsubara
641  || energyType == EnergyType::BosonicMatsubara,
642  "GreensFunction::getLowerMatsubaraEnergyIndex()",
643  "The Property is not of the type"
644  << " EnergyType::FermionicMatsubara or"
645  << " EnergyType::BosonicMatsubara.",
646  ""
647  );
648 
649  return descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex;
650 }
651 
652 template<typename DataType>
654 ) const{
655  TBTKAssert(
656  energyType == EnergyType::FermionicMatsubara
657  || energyType == EnergyType::BosonicMatsubara,
658  "GreensFunction::getUpperMatsubaraEnergyIndex()",
659  "The Property is not of the type"
660  << " EnergyType::FermionicMatsubara or"
661  << " EnergyType::BosonicMatsubara.",
662  ""
663  );
664 
665  return descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
666  + 2*(descriptor.matsubaraEnergy.numMatsubaraEnergies - 1);
667 }
668 
669 template<typename DataType>
671  TBTKAssert(
672  energyType == EnergyType::FermionicMatsubara
673  || energyType == EnergyType::BosonicMatsubara,
674  "GreensFunction::getNumMatsubaraEnergies()",
675  "The Property is not of the type"
676  << " EnergyType::FermionicMatsubara or"
677  << " EnergyType::BosonicMatsubara.",
678  ""
679  );
680 
681  return descriptor.matsubaraEnergy.numMatsubaraEnergies;
682 }
683 
684 template<typename DataType>
685 inline double EnergyResolvedProperty<
686  DataType
688  TBTKAssert(
689  energyType == EnergyType::FermionicMatsubara
690  || energyType == EnergyType::BosonicMatsubara,
691  "GreensFunction::getFundamentalMatsubaraEnergy()",
692  "The Property is not of the type"
693  << " EnergyType::FermionicMatsubara or"
694  << " EnergyType::BosonicMatsubara.",
695  ""
696  );
697 
698  return descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy;
699 }
700 
701 template<typename DataType>
703 ) const{
704  TBTKAssert(
705  energyType == EnergyType::FermionicMatsubara
706  || energyType == EnergyType::BosonicMatsubara,
707  "GreensFunction::getLowerMatsubaraEnergy()",
708  "The Property is not of the type"
709  << " EnergyType::FermionicMatsubara or"
710  << " EnergyType::BosonicMatsubara.",
711  ""
712  );
713 
714  return descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
715  *descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy;
716 }
717 
718 template<typename DataType>
720 ) const{
721  TBTKAssert(
722  energyType == EnergyType::FermionicMatsubara
723  || energyType == EnergyType::BosonicMatsubara,
724  "GreensFunction::getUpperMatsubaraEnergyIndex()",
725  "The Property is not of the type"
726  << " EnergyType::FermionicMatsubara or"
727  << " EnergyType::BosonicMatsubara.",
728  ""
729  );
730 
731  return (
732  descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex
733  + 2*(descriptor.matsubaraEnergy.numMatsubaraEnergies-1)
734  )*descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy;
735 }
736 
737 template<typename DataType>
738 inline std::complex<double> EnergyResolvedProperty<
739  DataType
741  unsigned int n
742 ) const{
743  TBTKAssert(
744  energyType == EnergyType::FermionicMatsubara
745  || energyType == EnergyType::BosonicMatsubara,
746  "GreensFunction::getMatsubaraEnergy()",
747  "The Property is not of the type"
748  << " EnergyType::FermionicMatsubara or"
749  << " EnergyType::BosonicMatsubara.",
750  ""
751  );
752 
753  return std::complex<double>(
754  0,
755  (descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex + 2*(int)n)
756  *descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy
757  );
758 }
759 
760 template<typename DataType>
762  switch(mode){
763  case Serializable::Mode::JSON:
764  {
765  nlohmann::json j;
766  j["id"] = "EnergyResolvedProperty";
767  switch(energyType){
768  case EnergyType::Real:
769  j["energyType"] = "Real";
770  j["lowerBound"] = descriptor.realEnergy.lowerBound;
771  j["upperBound"] = descriptor.realEnergy.upperBound;
772  j["resolution"] = descriptor.realEnergy.resolution;
773 
774  break;
775  case EnergyType::FermionicMatsubara:
776  j["energyType"] = "FermionicMatsubara";
777  j["lowerMatsubaraEnergyIndex"]
778  = descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex;
779  j["numMatsubaraEnergies"]
780  = descriptor.matsubaraEnergy.numMatsubaraEnergies;
781  j["fundamentalMatsubaraEnergy"]
782  = descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy;
783 
784  break;
785  case EnergyType::BosonicMatsubara:
786  j["energyType"] = "BosonicMatsubara";
787  j["lowerMatsubaraEnergyIndex"]
788  = descriptor.matsubaraEnergy.lowerMatsubaraEnergyIndex;
789  j["numMatsubaraEnergies"]
790  = descriptor.matsubaraEnergy.numMatsubaraEnergies;
791  j["fundamentalMatsubaraEnergy"]
792  = descriptor.matsubaraEnergy.fundamentalMatsubaraEnergy;
793 
794  break;
795  default:
796  TBTKExit(
797  "Property::EnergyResolvedProperty::serialize()",
798  "Unknown EnergyType.",
799  "This should never happen, contact the developer."
800  );
801  }
802  j["abstractProperty"] = nlohmann::json::parse(
804  );
805 
806  return j.dump();
807  }
808  default:
809  TBTKExit(
810  "Property::EnergyResolvedProperty::serialize()",
811  "Only Serializable::Mode::JSON is supported yet.",
812  ""
813  );
814  }
815 }
816 
817 }; //End namespace Property
818 }; //End namespace TBTK
819 
820 #endif
double getUpperMatsubaraEnergy() const
Definition: EnergyResolvedProperty.h:719
double getUpperBound() const
Definition: EnergyResolvedProperty.h:590
int getUpperMatsubaraEnergyIndex() const
Definition: EnergyResolvedProperty.h:653
static std::string extract(const std::string &serialization, Mode mode, std::string component)
Precompiler macros.
Definition: Serializable.h:40
double getLowerMatsubaraEnergy() const
Definition: EnergyResolvedProperty.h:702
Base class for energy resolved Properties.
Definition: EnergyResolvedProperty.h:37
std::complex< double > getMatsubaraEnergy(unsigned int n) const
Definition: EnergyResolvedProperty.h:740
double getLowerBound() const
Definition: EnergyResolvedProperty.h:578
Abstract Property class.
Definition: AbstractProperty.h:95
Data structure for mapping physical indices to linear indices.
Definition: IndexTree.h:34
EnergyResolvedProperty()
Definition: EnergyResolvedProperty.h:237
Definition: ModelFactory.h:35
unsigned int getNumMatsubaraEnergies() const
Definition: EnergyResolvedProperty.h:670
Mode
Definition: Serializable.h:44
virtual std::string serialize(Serializable::Mode mode) const
Definition: EnergyResolvedProperty.h:761
double getEnergy(unsigned int n) const
Definition: EnergyResolvedProperty.h:614
static bool validate(const std::string &serialization, const std::string &id, Mode mode)
EnergyType
Definition: EnergyResolvedProperty.h:40
unsigned int getResolution() const
Definition: EnergyResolvedProperty.h:602
int getLowerMatsubaraEnergyIndex() const
Definition: EnergyResolvedProperty.h:637
double getFundamentalMatsubaraEnergy() const
Definition: EnergyResolvedProperty.h:687