Program Listing for File task.hpp

↰ Return to documentation for file (src/task/task.hpp)

#pragma once

#include <filesystem>
#include <map>
#include <string>
#include <variant>
#include <vector>

#include "fields.hpp"
#include "input.hpp"
#include "parameter.hpp"
#include "particle.hpp"
#include "track_particle.hpp"

namespace lili::task {

enum class TaskType {
  Base,
  CreateOutput,
  InitParticles,
  InitFields,
  MoveParticlesFull,
};

enum class SimVarType {
  EMFields,
  ParticlesVector,
  TrackParticlesVector,
};

class Task {
 public:
  // Constructor
  Task() : type_(TaskType::Base), name_("") {}
  Task(TaskType type) : type_(type), name_("") {}
  Task(std::string name) : type_(TaskType::Base), name_(name) {}

  // Getters

  TaskType type() const { return type_; }

  std::string name() const { return name_; }

  bool is_initialized() const { return is_init_; }

  int i_run() const { return i_run_; }

  bool is_cleaned() const { return is_cleaned_; }

  // Setters

  void set_name(std::string name) { name_ = name; }

  int IncrementRun() { return i_run_++; }

  virtual void Initialize() { is_init_ = true; }

  virtual void Execute() {
    // Increment the run counter
    IncrementRun();
  }

  virtual void CleanUp() { is_cleaned_ = true; }

 private:
  TaskType type_;
  std::string name_;
  bool is_init_ = false;
  int i_run_ = 0;
  bool is_cleaned_ = false;
};

class TaskCreateOutput : public Task {
 public:
  // Constructor
  TaskCreateOutput() : Task(TaskType::CreateOutput) {
    set_name("CreateOutput");
  }
  TaskCreateOutput(std::string output_folder) : Task(TaskType::CreateOutput) {
    lili::output_folder = output_folder;
    set_name("CreateOutput");
  }

  void Initialize() override {
    std::string output_folder = lili::output_folder;
    if (!std::filesystem::is_directory(output_folder)) {
      std::filesystem::create_directory(output_folder);
    }
    std::cout << "Output folder : " << output_folder << std::endl;

    // Call the base class Initialize
    Task::Initialize();
  }
};

// Global variables
extern std::vector<std::unique_ptr<Task>> default_task_list;

extern std::vector<std::unique_ptr<Task>> loop_task_list;

extern std::map<
    task::SimVarType,
    std::variant<std::unique_ptr<mesh::Fields>,
                 std::unique_ptr<std::vector<particle::Particles>>,
                 std::unique_ptr<std::vector<particle::TrackParticles>>>>
    sim_vars;

void InitializeTask(Task* task);

void ExecuteTask(Task* task);

void CleanUpTask(Task* task);

void ParseTaskList(input::Input& input);
}  // namespace lili::task