ObjPropagationStepsWriter.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file ObjPropagationStepsWriter.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2017 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Propagator/detail/SteppingLogger.hpp"
#include "ActsExamples/Framework/WriterT.hpp"
#include "ActsExamples/Utilities/Paths.hpp"

#include <fstream>

namespace ActsExamples {

template <typename step_t>
class ObjPropagationStepsWriter
    : public WriterT<std::vector<std::vector<step_t>>> {
 public:
  struct Config {
    std::string collection;      
    std::string outputDir;       
    double outputScalor = 1.0;   
    size_t outputPrecision = 6;  
  };

  ObjPropagationStepsWriter(const Config& cfg,
                            Acts::Logging::Level level = Acts::Logging::INFO)
      : WriterT<std::vector<std::vector<step_t>>>(cfg.collection,
                                                  "ObjSpacePointWriter", level),
        m_cfg(cfg) {
    if (m_cfg.collection.empty()) {
      throw std::invalid_argument("Missing input collection");
    }
  }

  ~ObjPropagationStepsWriter() override = default;

  ProcessCode finalize() override { return ActsExamples::ProcessCode::SUCCESS; }

  const Config& config() const { return m_cfg; }

 private:
  Config m_cfg;  

 protected:
  ProcessCode writeT(
      const AlgorithmContext& context,
      const std::vector<std::vector<step_t>>& stepCollection) override {
    // open per-event file
    std::string path = ActsExamples::perEventFilepath(
        m_cfg.outputDir, "propagation-steps.obj", context.eventNumber);
    std::ofstream os(path, std::ofstream::out | std::ofstream::trunc);
    if (!os) {
      throw std::ios_base::failure("Could not open '" + path + "' to write");
    }

    // Initialize the vertex counter
    unsigned int vCounter = 0;

    for (auto& steps : stepCollection) {
      // At least three points to draw
      if (steps.size() > 2) {
        // We start from one
        ++vCounter;
        for (auto& step : steps) {
          // Write the space point
          os << "v " << m_cfg.outputScalor * step.position.x() << " "
             << m_cfg.outputScalor * step.position.y() << " "
             << m_cfg.outputScalor * step.position.z() << '\n';
        }
        // Write out the line - only if we have at least two points created
        size_t vBreak = vCounter + steps.size() - 1;
        for (; vCounter < vBreak; ++vCounter) {
          os << "l " << vCounter << " " << vCounter + 1 << '\n';
        }
      }
    }
    return ActsExamples::ProcessCode::SUCCESS;
  }
};

}  // namespace ActsExamples