CouetteConfiguration.h

// Copyright (C) 2016 Technische Universitaet Muenchen
// This file is part of the Mamico project. For conditions of distribution
// and use, please see the copyright notice in Mamico's main folder, or at
// www5.in.tum.de/mamico
#ifndef _COUETTECONFIG_H_
#define _COUETTECONFIG_H_
 
#include "tarch/configuration/ParseConfiguration.h"
#include "tarch/la/Vector.h"
 
using tarch::configuration::ParseConfiguration;
 
namespace coupling {
namespace configurations {
 
struct CouetteConfig;
}
} // namespace coupling
struct coupling::configurations::CouetteConfig {
 
private:
  // CouetteConfig(){}
 
public:
  enum MacroSolverType {
    COUETTE_ANALYTICAL = 0, 
    COUETTE_LB = 1,         
    COUETTE_FD = 2,         
    COUETTE_FOAM = 3        
  };

  enum MicroSolverType {
    SIMPLEMD = 0,  
    SYNTHETIC = 1, 
    LS1 = 2        
  };

  static CouetteConfig parseCouetteConfiguration(const std::string& filename) {
    CouetteConfig cfg;
 
    ParseConfiguration::XMLConfiguration xmlConfig = ParseConfiguration::XMLConfiguration::load(filename);
    tinyxml2::XMLElement* node = xmlConfig.root->FirstChildElement("couette-test");
 
    if (node == NULL) {
      std::cout << "Could not read input file " << filename
                << ": missing element "
                   "<couette-test>"
                << std::endl;
      exit(EXIT_FAILURE);
    }
 
    tinyxml2::XMLElement* n_mamico = node->NextSiblingElement();
    if (n_mamico == NULL) {
      std::cout << "Could not read input file " << filename << ": missing element <mamico>" << std::endl;
      exit(EXIT_FAILURE);
    }
    tinyxml2::XMLElement* n_md = n_mamico->NextSiblingElement();
    if (n_md == NULL) {
      std::cout << "Could not read input file " << filename
                << ": missing element "
                   "<molecular-dynamics>"
                << std::endl;
      exit(EXIT_FAILURE);
    }
    tinyxml2::XMLElement* n_fp = n_md->NextSiblingElement();
    if (n_fp == NULL) {
      std::cout << "Could not read input file " << filename
                << ": missing element "
                   "<filter-pipeline>"
                << std::endl;
      exit(EXIT_FAILURE);
    }
    tinyxml2::XMLElement* n_unexpected = n_fp->NextSiblingElement();
    if (n_unexpected != NULL) {
      std::cout << "Could not read input file " << filename << ": unknown element " << n_unexpected->Name() << std::endl;
      exit(EXIT_FAILURE);
    }
 
    tinyxml2::XMLElement* subtag = node->FirstChildElement("domain");
    if (subtag == NULL) {
      std::cout << "Could not read input file " << filename << ": Missing subtag: domain" << std::endl;
      exit(EXIT_FAILURE);
    }
    tarch::configuration::ParseConfiguration::readDoubleMandatory(cfg.channelheight, subtag, "channelheight");
    tarch::configuration::ParseConfiguration::readVectorMandatory<3, double>(cfg.wallVelocity, subtag, "wall-velocity");
    cfg.wallInitCycles = 0;
    tarch::configuration::ParseConfiguration::readIntOptional(cfg.wallInitCycles, subtag, "wall-init-cycles");
    if (cfg.wallInitCycles > 0)
      tarch::configuration::ParseConfiguration::readVectorMandatory<3, double>(cfg.wallInitVelocity, subtag, "wall-init-velocity");
    cfg.wallOscillations = 0;
    tarch::configuration::ParseConfiguration::readDoubleOptional(cfg.wallOscillations, subtag, "wall-oscillations");
 
    subtag = node->FirstChildElement("coupling");
    if (subtag == NULL) {
      std::cout << "Could not read input file couette.xml: Missing subtag: coupling" << std::endl;
      exit(EXIT_FAILURE);
    }
    tarch::configuration::ParseConfiguration::readIntMandatory(cfg.couplingCycles, subtag, "coupling-cycles");
    tarch::configuration::ParseConfiguration::readBoolMandatory(cfg.twoWayCoupling, subtag, "two-way-coupling");
    tarch::configuration::ParseConfiguration::readBoolMandatory(cfg.md2Macro, subtag, "send-from-md-to-macro");
    tarch::configuration::ParseConfiguration::readBoolMandatory(cfg.macro2Md, subtag, "send-from-macro-to-md");
    tarch::configuration::ParseConfiguration::readIntMandatory(cfg.filterInitCycles, subtag, "filter-init-cycles");
    tarch::configuration::ParseConfiguration::readIntMandatory(cfg.csvEveryTimestep, subtag, "write-csv-every-timestep");
    tarch::configuration::ParseConfiguration::readBoolMandatory(cfg.computeSNR, subtag, "compute-snr");
 
    subtag = node->FirstChildElement("microscopic-solver");
    if (subtag == NULL) {
      std::cout << "Could not read input file " << filename
                << ": Missing subtag: "
                   "microscopic-solver"
                << std::endl;
      exit(EXIT_FAILURE);
    }
    std::string type;
    tarch::configuration::ParseConfiguration::readStringMandatory(type, subtag, "type");
    if (type == "md") {
      cfg.miSolverType = SIMPLEMD;
      tarch::configuration::ParseConfiguration::readDoubleMandatory(cfg.temp, subtag, "temperature");
      tarch::configuration::ParseConfiguration::readIntMandatory(cfg.equSteps, subtag, "equilibration-steps");
 
      std::string num_MD;
      tarch::configuration::ParseConfiguration::readStringMandatory(num_MD, subtag, "number-md-simulations");
      if (num_MD == "dynamic") {
        cfg.totalNumberMDSimulations = -1;
        cfg.lowerBoundNumberMDSimulations = 1;
        tarch::configuration::ParseConfiguration::readIntOptional(cfg.lowerBoundNumberMDSimulations, subtag, "min-number-md");
        tarch::configuration::ParseConfiguration::readDoubleMandatory(cfg.absVelErrStart, subtag, "error-start");
        tarch::configuration::ParseConfiguration::readDoubleMandatory(cfg.absVelErrEnd, subtag, "error-end");
      } else {
        tarch::configuration::ParseConfiguration::readIntMandatory(cfg.totalNumberMDSimulations, subtag, "number-md-simulations");
        if (cfg.totalNumberMDSimulations < 1) {
          std::cout << "Could not read input file " << filename
                    << ": "
                       "number-md-simulations < 1"
                    << std::endl;
          exit(EXIT_FAILURE);
        }
      }
    } else if (type == "synthetic") {
      cfg.miSolverType = SYNTHETIC;
      tarch::configuration::ParseConfiguration::readDoubleMandatory(cfg.noiseSigma, subtag, "noise-sigma");
      cfg.totalNumberMDSimulations = 1;
      tarch::configuration::ParseConfiguration::readIntOptional(cfg.totalNumberMDSimulations, subtag, "number-md-simulations");
    } else if (type == "ls1") {
      cfg.miSolverType = LS1;
 
      cfg.totalNumberMDSimulations = 1;
      tarch::configuration::ParseConfiguration::readDoubleMandatory(cfg.temp, subtag, "temperature");
      tarch::configuration::ParseConfiguration::readIntMandatory(cfg.equSteps, subtag, "equilibration-steps");
      tarch::configuration::ParseConfiguration::readIntOptional(cfg.totalNumberMDSimulations, subtag, "number-md-simulations");
    } else {
      std::cout << "Could not read input file " << filename
                << ": Unknown microscopic "
                   "solver type!"
                << std::endl;
      exit(EXIT_FAILURE);
    }
    tarch::configuration::ParseConfiguration::readDoubleMandatory(cfg.density, subtag, "density");
 
    subtag = node->FirstChildElement("macroscopic-solver");
    if (subtag == NULL) {
      std::cout << "Could not read input file " << filename
                << ": Missing subtag: "
                   "macroscopic-solver"
                << std::endl;
      exit(EXIT_FAILURE);
    }
    cfg.lbNumberProcesses = tarch::la::Vector<3, unsigned int>(1);
    tarch::configuration::ParseConfiguration::readStringMandatory(type, subtag, "type");
    if (type == "lb") {
      cfg.maSolverType = COUETTE_LB;
      tarch::configuration::ParseConfiguration::readVectorMandatory<3, unsigned int>(cfg.lbNumberProcesses, subtag, "number-of-processes");
      tarch::configuration::ParseConfiguration::readIntMandatory(cfg.plotEveryTimestep, subtag, "plot-every-timestep");
    } else if (type == "fd") {
      cfg.maSolverType = COUETTE_FD;
      tarch::configuration::ParseConfiguration::readVectorMandatory<3, unsigned int>(cfg.lbNumberProcesses, subtag, "number-of-processes");
      tarch::configuration::ParseConfiguration::readIntMandatory(cfg.plotEveryTimestep, subtag, "plot-every-timestep");
    }
#if (BUILD_WITH_OPENFOAM)
    else if (type == "foam") {
      cfg.maSolverType = COUETTE_FOAM;
      tarch::configuration::ParseConfiguration::readIntMandatory(cfg.plotEveryTimestep, subtag, "plot-every-timestep");
      tarch::configuration::ParseConfiguration::readStringMandatory(cfg.foam.directory, subtag, "foam-setup-directory");
      tarch::configuration::ParseConfiguration::readStringMandatory(cfg.foam.folder, subtag, "foam-setup-folder");
      tarch::configuration::ParseConfiguration::readVectorMandatory<12, unsigned int>(cfg.foam.boundariesWithMD, subtag, "boundaries-with-MD");
    }
#endif
    else if (type == "analytical") {
      cfg.maSolverType = COUETTE_ANALYTICAL;
      if (!(cfg.wallVelocity[1] == 0.0 && cfg.wallVelocity[2] == 0.0)) {
        std::cout << "analytic solver only supports flow in x-direction" << std::endl;
        exit(EXIT_FAILURE);
      }
    } else {
      std::cout << "Could not read input file " << filename
                << ": Unknown macroscopic "
                   "solver type!"
                << std::endl;
      exit(EXIT_FAILURE);
    }
    double vis;
    tarch::configuration::ParseConfiguration::readDoubleMandatory(vis, subtag, "viscosity");
    cfg.kinVisc = vis / cfg.density;
    tarch::configuration::ParseConfiguration::readIntMandatory(cfg.initAdvanceCycles, subtag, "init-advance-cycles");
 
    subtag = node->FirstChildElement("tws-loop");
    if (subtag == NULL)
      cfg.twsLoop = false;
    else {
      cfg.twsLoop = true;
      tarch::configuration::ParseConfiguration::readIntMandatory(cfg.twsLoopMin, subtag, "min");
      tarch::configuration::ParseConfiguration::readIntMandatory(cfg.twsLoopMax, subtag, "max");
      cfg.twsLoopStep = 1;
      tarch::configuration::ParseConfiguration::readIntOptional(cfg.twsLoopStep, subtag, "step");
    }
 
    if (cfg.miSolverType == SYNTHETIC) {
      if (cfg.macro2Md || cfg.totalNumberMDSimulations > 1 || cfg.lbNumberProcesses[0] != 1 || cfg.lbNumberProcesses[1] != 1 || cfg.lbNumberProcesses[2] != 1) {
        std::cout << "Invalid configuration: Synthetic MD runs sequentially on "
                     "rank 0 only. "
                  << "It does neither support parallel communication nor "
                     "multi-instance sampling"
                  << std::endl;
        exit(EXIT_FAILURE);
      }
    }
    if (cfg.maSolverType == COUETTE_ANALYTICAL) {
      if (cfg.twoWayCoupling) {
        std::cout << "Invalid configuration: COUETTE_ANALYTICAL does not "
                     "support twoWayCoupling"
                  << std::endl;
        exit(EXIT_FAILURE);
      }
    }
 
    return cfg;
  }
 
#if (BUILD_WITH_OPENFOAM)
  struct FoamConfig {
    std::string directory;
    std::string folder;
    tarch::la::Vector<12, unsigned int> boundariesWithMD;
  };
#endif

  double channelheight;
  tarch::la::Vector<3, double> wallVelocity;
  int wallInitCycles;
  tarch::la::Vector<3, double> wallInitVelocity;
  double wallOscillations;
  int couplingCycles;
  bool md2Macro;
  bool macro2Md;
  bool computeSNR;
  bool twoWayCoupling;
  int filterInitCycles;
  int csvEveryTimestep;
  MacroSolverType maSolverType;
  MicroSolverType miSolverType;
  double density;
  double kinVisc;
  tarch::la::Vector<3, unsigned int> lbNumberProcesses;
  int plotEveryTimestep;
  int initAdvanceCycles;
  double temp;
  int equSteps;
  int totalNumberMDSimulations;
  int lowerBoundNumberMDSimulations;
  double absVelErrStart;
  double absVelErrEnd;
  double noiseSigma;
  bool twsLoop;
  int twsLoopMin;
  int twsLoopMax;
  int twsLoopStep;
 
#if (BUILD_WITH_OPENFOAM)
  FoamConfig foam;
#endif
};
 
#endif