tofsimulation.h

Go to the documentation of this file.

/*
 *            Copyright 2009-2026 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.
 *
 */
 
#pragma once
#ifndef VOTCA_XTP_TOFSIMULATION_H
#define VOTCA_XTP_TOFSIMULATION_H
 
// Standard includes
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
// Local VOTCA includes
#include "kmcengine.h"
#include "kmcrates.h"
#include "kmcwaitingtime.h"
#include "tofgraph.h"
 
namespace votca {
namespace xtp {

class ToFSimulation {
 public:
  struct Settings {
    std::uint64_t seed = 1;
    Index runs = 1000;
    std::vector<KMCEngine::Pulse> pulses = {KMCEngine::Pulse{}};
    KMCEngine::Limits limits;
    double tmin = 1e-15;  // s, current/collection time axis
    double tmax = 1.0;
    Index bins_per_decade = 10;
  };
 
  struct RunData {
    KMCEngine::RunStatus status;
    double first_arrival = 0.0;  // valid if status.absorbed > 0
    double mean_transit = 0.0;   // valid if status.absorbed > 0
  };
 
  struct Statistic {
    Index samples = 0;
    double mean = 0.0;
    double standard_error = 0.0;
    double standard_deviation = 0.0;
    double top_percent_share = 0.0;
  };
 
  struct Result {
    std::vector<RunData> runs;
    Index censored = 0;
    Index injected = 0;
    Index blocked_injections = 0;
    Index hops = 0;
    Index null_events = 0;
    Statistic first;                // over uncensored runs
    Statistic transit;              // over uncensored runs
    std::vector<double> bin_edges;  // s, size bins + 1
    std::vector<double> current;    // 1/s, per bin
    std::vector<double> collected;  // fraction absorbed by the bin end
    double displacement_before = 0.0;
    double displacement_after = 0.0;
  };

  ToFSimulation(const ToFGraph& graph, const Settings& settings);

  ToFSimulation(const ToFGraph& graph, const Settings& settings,
                const TimeDependentRates& rates, WaitingTimeStrategy& strategy);
 
  const std::string& StrategyName() const { return strategy_name_; }
 
  Result Simulate() const;
 
  static Statistic Analyze(std::vector<double> samples);
 
 private:
  RunData SingleRun(Index run, std::vector<double>& current,
                    std::vector<double>& arrivals, double& before,
                    double& after) const;
  Index Bin(double t) const;
 
  void Setup();
 
  const ToFGraph& graph_;
  Settings settings_;
  std::unique_ptr<StaticRates> own_rates_;
  std::unique_ptr<WaitingTimeStrategy> own_strategy_;
  std::unique_ptr<KMCEngine> engine_;
  std::string strategy_name_;
  std::vector<double> edges_;
};
 
}  // namespace xtp
}  // namespace votca
 
#endif  // VOTCA_XTP_TOFSIMULATION_H