Codebase list votca-xtp / scrub-obsolete/main src / libxtp / calculators / einternal.cc
scrub-obsolete/main

Tree @scrub-obsolete/main (Download .tar.gz)

einternal.cc @scrub-obsolete/main — raw · history · blame 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
/*
 * Copyright 2009-2020 The VOTCA Development Team (http://www.votca.org)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

// Local VOTCA includes
#include "votca/xtp/topology.h"

// Local private VOTCA includes
#include "einternal.h"

namespace votca {
namespace xtp {

void EInternal::ParseOptions(const tools::Property &options) {

  _energiesXML = options.get(".energiesXML").as<std::string>();
}

void EInternal::ParseEnergies() {

  std::cout << "\n... ... Site, reorg. energies from " << _energiesXML << ".\n";

  tools::Property alloc;
  alloc.LoadFromXML(_energiesXML);

  std::string key = "topology.molecules.molecule";
  std::vector<tools::Property *> mols = alloc.Select(key);
  for (tools::Property *molprop : mols) {

    key = "segments.segment";
    std::vector<tools::Property *> segs = molprop->Select(key);
    for (tools::Property *segprop : segs) {

      std::string segName = segprop->get("name").as<std::string>();

      bool has_seg = true;

      QMStateCarrierStorage<double> U_xX_nN;
      QMStateCarrierStorage<double> U_nX_nN;
      QMStateCarrierStorage<double> U_xN_xX;
      QMStateCarrierStorage<bool> has_state;
      double eV2hrt = tools::conv::ev2hrt;

      std::vector<QMStateType> types = {QMStateType::Electron,
                                        QMStateType::Hole, QMStateType::Singlet,
                                        QMStateType::Triplet};
      for (QMStateType type : types) {
        std::string u_xX_nN = "U_xX_nN_" + type.ToString();
        std::string u_nX_nN = "U_nX_nN_" + type.ToString();
        std::string u_xN_xX = "U_xN_xX_" + type.ToString();
        if (segprop->exists(u_xX_nN) && segprop->exists(u_nX_nN) &&
            segprop->exists(u_xN_xX)) {
          U_xX_nN.setValue(segprop->get(u_xX_nN).as<double>() * eV2hrt, type);
          U_nX_nN.setValue(segprop->get(u_nX_nN).as<double>() * eV2hrt, type);
          U_xN_xX.setValue(segprop->get(u_xN_xX).as<double>() * eV2hrt, type);
          has_state.setValue(true, type);
        }
      }
      _seg_has_state[segName] = has_state;
      _seg_U_xX_nN[segName] = U_xX_nN;
      _seg_U_nX_nN[segName] = U_nX_nN;
      _seg_U_xN_xX[segName] = U_xN_xX;

      _has_seg[segName] = has_seg;
    }
  }
}

bool EInternal::Evaluate(Topology &top) {

  ParseEnergies();

  Index count = 0;
  for (Segment &seg : top.Segments()) {

    std::string segName = seg.getType();

    if (!_has_seg.count(segName)) {
      std::cout << std::endl
                << "... ... WARNING: No energy information for seg [" << segName
                << "]. Skipping... ";
      continue;
    }

    ++count;

    std::vector<QMStateType> types = {QMStateType::Electron, QMStateType::Hole,
                                      QMStateType::Singlet,
                                      QMStateType::Triplet};
    for (QMStateType type : types) {

      if (_seg_has_state[segName].getValue(type.Type())) {
        seg.setU_xX_nN(_seg_U_xX_nN[segName].getValue(type.Type()),
                       type.Type());
        seg.setU_nX_nN(_seg_U_nX_nN[segName].getValue(type.Type()),
                       type.Type());
        seg.setU_xN_xX(_seg_U_xN_xX[segName].getValue(type.Type()),
                       type.Type());
      }
    }
  }

  std::cout << std::endl
            << "... ... Read in site, reorg. energies for " << count
            << " segments. " << std::flush;

  return true;
}

}  // namespace xtp
}  // namespace votca