jfernandez/mmoc/annotation_8hpp_source.html

/*****************************************************************************


 This file is part of QSS Solver.


 QSS Solver is free software: you can redistribute it and/or modify

 it under the terms of the GNU General Public License as published by

 the Free Software Foundation, either version 3 of the License, or

 (at your option) any later version.


 QSS Solver is distributed in the hope that it will be useful,

 but WITHOUT ANY WARRANTY; without even the implied warranty of

 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 GNU General Public License for more details.


 You should have received a copy of the GNU General Public License

 along with QSS Solver.  If not, see <http://www.gnu.org/licenses/>.


 ******************************************************************************/


#pragma once


#include <list>

#include <map>

#include <string>

#include <boost/variant/variant_fwd.hpp>


#include <ast/ast_types.hpp>

#include <ir/model_matrix_gen.hpp>

#include <util/ast_util.hpp>

#include <util/util_types.hpp>


namespace MicroModelica {

namespace IR {


enum class Solver {

  QSS,

  CQSS,

  LIQSS,

  QSS2,

  LIQSS2,

  LIQSS_BDF,

  QSS3,

  LIQSS3,

  QSS4,

  DASSL,

  DOPRI,

  CVODE_BDF,

  CVODE_AM,

  IDA,

  mLIQSS,

  mLIQSS2

};


enum class DT_Synch { DT_Fixed, DT_Asynchronous };


class FunctionAnnotation {

  public:

  FunctionAnnotation();

  ~FunctionAnnotation() = default;

  bool hasDerivative();

  bool hasInclude();

  bool hasIncludeDirectory();

  bool hasLibraries();

  bool hasLibraryDirectory();

  bool insert(AST_Argument_Modification x);

  string derivative();

  string include();

  string includeDirectory();

  Util::SymbolTable libraries() const;

  string libraryDirectory();


  protected:

  enum class type { INCLUDE, INCLUDE_DIRECTORY, LIBRARY, LIBRARY_DIRECTORY, DERIVATIVE };


  void initialize();


  map<std::string, FunctionAnnotation::type> _annotations;

  std::string _derivative;

  std::string _include;

  std::string _includeDirectory;

  Util::SymbolTable _libraries;

  std::string _libraryDirectory;

};


enum class IntegerAnnotations { RandomSeed, CVODEMaxOrder, XOutput };


class ModelAnnotation {

  public:

  ModelAnnotation();

  ~ModelAnnotation() = default;

  void expComment(AST_Comment x, int id);

  bool insert(AST_Argument_Modification x);

  string desc();

  list<double> dqmin();

  list<double> dqrel();

  double weight();

  Solver solver();

  string solverString();

  double initialTime();

  double finalTime();

  double minStep();

  double ZCHyst();

  double derDelta();

  double DT();

  int lps();

  void setNodeSize(int ns);

  int nodeSize();

  string commInterval();

  list<double> sample();

  bool symDiff();

  int order();

  string scheduler();

  list<AST_Expression> output();

  string storeData();

  string partitionMethodString();

  bool parallel();

  int polyCoeffs();

  string dtSynchString();

  DT_Synch dtSynch();

  list<string> patohSettings();

  list<string> scotchSettings();

  list<string> metisSettings();

  int jacobian();

  bool isClassic();

  AST_ExpressionList BDFPartition();

  int BDFPartitionDepth();

  double BDFMaxStep();

  string EventId();

  IR::MATRIX::UserDefMatrixExps HDMatrix();

  IR::MATRIX::UserDefMatrixExps HZMatrix();

  IR::MATRIX::UserDefMatrixExps HHMatrix();

  IR::MATRIX::UserDefMatrixExps LHSSTMatrix();

  IR::MATRIX::UserDefMatrixExps LHSDSCMatrix();

  IR::MATRIX::UserDefMatrixExps RHSSTMatrix();

  IR::MATRIX::UserDefMatrixExps SDMatrix();

  IR::MATRIX::UserDefMatrixExps SZMatrix();

  int getAnnotation(IntegerAnnotations annot) const;

  bool hasAnnotation(IntegerAnnotations annot) const;


  protected:

  enum class type {

    EXPERIMENT,

    DESC,

    DQMIN,

    DQREL,

    WEIGHT,

    SOLVER,

    INITIAL_TIME,

    FINAL_TIME,

    MIN_STEP,

    ZCHYST,

    DER_DELTA,

    LPS,

    NODE_SIZE,

    COMM_INTERVAL,

    STEP_SIZE,

    SYM_DIFF,

    SCHEDULER,

    OUTPUT,

    STORE_DATA,

    PARTITION_METHOD,

    PARALLEL,

    DELTAT,

    DELTAT_SYNCH,

    PATOH_SETTINGS,

    SCOTCH_SETTINGS,

    METIS_SETTINGS,

    JACOBIAN,

    BDF_PARTITION,

    BDF_PARTITION_DEPTH,

    BDF_MAX_STEP,

    EVENT_ID,

    HD_MATRIX,

    HZ_MATRIX,

    HH_MATRIX,

    LHS_ST_MATRIX,

    RHS_ST_MATRIX,

    LHS_DSC_MATRIX,

    SD_MATRIX,

    SZ_MATRIX,

    RANDOM_SEED,

    CV_ODE_MAX_ORDER,

    X_OUTPUT

  };


  using IntAnnotValMap = std::map<IntegerAnnotations, int>;


  void initialize();

  void processAnnotation(string annot, AST_Modification_Equal x);

  void processArgument(AST_Argument_Modification arg);

  void processList(AST_Expression x, list<double> *l);

  void processList(AST_Expression x, list<string> *l);

  void processExpressionList(AST_Expression x, AST_ExpressionList exps);

  Solver getSolver(string s);

  DT_Synch getDtSynch(string s);

  void parseMatrix(AST_Expression exp, IR::MATRIX::UserDefMatrixExps &matrix);


  Solver _solver;

  string _solverString;

  string _commInterval;

  bool _symDiff;

  double _minStep;

  int _lps;

  double _derDelta;

  int _nodeSize;

  double _ZCHyst;

  int _order;

  string _scheduler;

  string _storeData;

  map<string, ModelAnnotation::type> _annotations;

  list<double> _DQMin;

  list<double> _DQRel;

  double _weight;

  list<double> _sample;

  list<AST_Expression> _output;

  double _initialTime;

  double _finalTime;

  string _partition_method_string;

  bool _parallel;

  double _dt;

  int _polyCoeffs;

  DT_Synch _dtSynch;

  string _dtSynchString;

  string _desc;

  list<string> _patohSettings;

  list<string> _scotchSettings;

  list<string> _metisSettings;

  int _jacobian;

  AST_ExpressionList _BDFPartition;

  int _BDFPartitionDepth;

  double _BDFMaxStep;

  IR::MATRIX::UserDefMatrixExps _hd_matrix;

  IR::MATRIX::UserDefMatrixExps _hz_matrix;

  IR::MATRIX::UserDefMatrixExps _hh_matrix;

  IR::MATRIX::UserDefMatrixExps _lhs_st_matrix;

  IR::MATRIX::UserDefMatrixExps _rhs_st_matrix;

  IR::MATRIX::UserDefMatrixExps _lhs_dsc_matrix;

  IR::MATRIX::UserDefMatrixExps _sd_matrix;

  IR::MATRIX::UserDefMatrixExps _sz_matrix;

  string _event_ids;

  int _current_exp_id;

  map<string, IntegerAnnotations> _integer_annotations_map;

  IntAnnotValMap _integer_annotations_val;

};


using AnnotationType = boost::variant<ModelAnnotation, FunctionAnnotation>;


class AnnotationValue {

  public:

  AnnotationValue();

  ~AnnotationValue() = default;

  int integer();

  void setInteger(int i);

  double real();

  void setReal(double d);

  string str();

  void setStr(string s);

  string plainStr();

  void setPlainStr(string plain_str);


  protected:

  int _integer;

  double _real;

  string _str;

  string _plain_str;

};


class EvalAnnotation : public AST_Expression_Fold<AnnotationValue> {

  public:

  EvalAnnotation();

  ~EvalAnnotation() override = default;


  private:

  void setBoolean(bool condition, AnnotationValue *e);

  AnnotationValue foldTraverseElement(AST_Expression) override;

  AnnotationValue foldTraverseElement(AnnotationValue, AnnotationValue, BinOpType) override;

  AnnotationValue foldTraverseElementUMinus(AST_Expression) override;

  std::vector<string> _tokens;

};

}  // namespace IR

}  // namespace MicroModelica