fsi/motion-amroc/WindTurbine_Terrain/src/SolidProblem.h

Go to the documentation of this file.

// -*- C++ -*-

#ifndef SOLID_PROBLEM_H
#define SOLID_PROBLEM_H

#define DIM 3
#define SML -1e10
#define LRG 1e10

#define maxAssemblies 10
#define maxSubAssemblies 10
#define maxParts 10
#define maxLevels 10

#define ChainLimit 10
#define maxSubChains 10
#define maxLinks 10
#define LinkLimit 20
#define maxJoints 2
#define JointLimit 10

#define MAX_TURBINES 6

#include "MotionSolver.h"
#include "MotionELCCoupledSolver.h"
#include "TurbineMechanism.h"
#include "Terrain.h"

class MotionSpecific : public MotionELCCoupledSolver<DataType,DIM> {
  typedef MotionELCCoupledSolver<DataType,DIM> base;
  typedef MotionSolver<DataType,DIM> MotionSolverbase;
public:
  MotionSpecific() : base() {
    num_turbines = 1;
  }

  virtual void register_at(ControlDevice& Ctrl) {
    register_at(Ctrl,"");
  }
  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {

    SLocCtrl = Ctrl.getSubDevice(prefix+"MotionSolver");
    RegisterAt(SLocCtrl,"FileType",brep_filetype);
    RegisterAt(SLocCtrl,"InputBrep",brep_filename);
    RegisterAt(SLocCtrl,"VelocityFile",vel_filename);
    RegisterAt(SLocCtrl,"OutputName",OutputName);
    RegisterAt(SLocCtrl,"CheckpointName",CheckpointName);

    RegisterAt(SLocCtrl,"Scale",scale);
    RegisterAt(SLocCtrl,"Center(1)",xs[0]);
    RegisterAt(SLocCtrl,"Center(2)",xs[1]);
    RegisterAt(SLocCtrl,"Center(3)",xs[2]);
    RegisterAt(SLocCtrl,"RotationDuration",Tr);
    RegisterAt(SLocCtrl,"dt",dtret);

    RegisterAt(SLocCtrl,"PrescribedMotion",prescribed);
    RegisterAt(SLocCtrl,"num_turbines",num_turbines);
    RegisterAt(SLocCtrl,"log_every",MotionSolverbase::log_every);

    RegisterAt(SLocCtrl,"SceneName",SceneName);

    for (register int i = 0; i < MAX_TURBINES; i++) {
      TurbineCtrls[i].register_at(SLocCtrl,prefix+"MotionSolver",i);
    }

    TerrainCtrl.register_at(SLocCtrl,prefix+"MotionSolver");
  }

  virtual bool specificSetup() {
    _Scene().setName(SceneName);
    for (register int i = 0; i < num_turbines; i++) {
      TurbineCtrls[i].print();
    }

    for (register int i = 0; i < num_turbines; i++) {
#ifdef MOTION_DEBUG_ON
      ( base::log() << "SolidProblem.h TurbineCtrls[" << i << "].tower_name = " << TurbineCtrls[i].tower_name << std::endl ).flush();
#endif
      ( base::log() << "SolidProblem.h TurbineCtrls[" << i << "].tower_name = " << TurbineCtrls[i].tower_name << std::endl ).flush();
      Turbines[i].specificSetup(_Scene(),&TurbineCtrls[i]);
    }

    Topology.specificSetup(_Scene(),&TerrainCtrl);
    for (register int i = 0; i < num_turbines; i++) {
      if ( TurbineCtrls[i].ontop == 1 ) {
        Turbines[i].ontop(_Scene(),&TurbineCtrls[i],TurbineCtrls[i].part_offset);
      }
    }
    _Scene().printSummary();

#ifdef MOTION_DEBUG_ON
    ( base::log() << "\tSolidSolverSpecific specificSetup END\n" ).flush();
#endif
    return true;
  }

  virtual void movement(double& t, double& dt) {
#ifdef MOTION_DEBUG_ON
    ( base::log() << "\n\n*********\tSolidSolverSpecific movement aDVANCE bEGIN\n*********" << std::endl ).flush();
    ( base::log() << " time = " << t << " time*DataType(360.0/6.) = " << t*DataType(360.0/6.)
              << " time*DataType(360.0/6.)*d2r = " << t*DataType(360.0/6.)*d2r << std::endl
              << " steps = " << steps << " dt = " << dt << std::endl ).flush();
#endif

    for (register int i = 0; i < num_turbines; i++) {
#ifdef MOTION_DEBUG_ON
      ( base::log() << "SolidProblem.h TurbineCtrls[" << i << "].tower_name = " << TurbineCtrls[i].tower_name << std::endl ).flush();
#endif
      if (prescribed == 1) {
        Turbines[i].movement(&Turbines[i],&TurbineCtrls[i], t, dt);
      }
      else {
        Turbines[i].response(&Turbines[i],&TurbineCtrls[i], t, dt, MotionSolverbase::NSteps(), MotionSolverbase::LogEvery() );
      }
    }

    if ( MotionSolverbase::NSteps() % MotionSolverbase::log_every == 0 ) {
      logKinetics();
    }

#ifdef MOTION_DEBUG_ON
    ( base::log() << "\n\n*********\tSolidSolverSpecific movement aDVANCE fINISHED\n*********" << std::endl ).flush();
#endif
  }

  virtual void logKinetics() {
    char fname[256];
    sprintf(fname,"%s_kinetics.json",CheckpointName.c_str());
    std::ofstream ofs;
    if ( ! fexists(fname) ) { //NSteps() < 1 ) {
      ofs.open(fname, std::ios::out);
      ofs << "{\n";
    }
    else {
      ofs.open(fname, std::ios::app);
    }
    ofs << "\t\"" << MotionSolverbase::NSteps() << "\": {\n";
    ofs << "\t\t\"time\": " << MotionSolverbase::CurrentTime() << ",\n";
    for (register int i = 0; i < num_turbines; i++) {
      Turbines[i].logKinetics(&Turbines[i],&TurbineCtrls[i], ofs, MotionSolverbase::CurrentTime(), MotionSolverbase::NSteps());
      if (i<num_turbines-1) ofs << ",";
      ofs << "\n";
    }
    ofs << "\t}," << std::endl;
    ofs.close();
  }

  virtual void Restart(double& t, double& dt) {
    MotionSolverbase::Restart(t,dt);
#ifdef CHECKRESTART_DEBUG_ON
    ( base::log() << "\nRestarting Solid Problem t= " << t << " dt = " << dt << " pos = " << MotionSolverbase::pos << std::endl ).flush();
#endif

    char fname[256];
    sprintf(fname,"%s.cp",CheckpointName.c_str());
    std::ifstream ifs(fname, std::ios::in);
    if (ifs.is_open()) {
      ( base::log() << " OPEN\n").flush();
    }
    else {
      ( base::log() << " CLOSED\n").flush();
    }
    ifs.seekg(MotionSolverbase::pos);
    ( base::log() << " num_turbines = " << num_turbines << std::endl ).flush();
    for (register int i=0; i < num_turbines; i++) {
      Turbines[i].Restart(ifs,pos,t,dt);
      pos = ifs.tellg();
    }
    Topology.Restart(ifs,pos,t,dt);
    pos = ifs.tellg();

#ifdef CHECKRESTART_DEBUG_ON
    ( base::log() << "\nDone Restarting Solid Problem t = " << t << " dt = " << dt << " pos = " << pos << std::endl ).flush();
#endif
    ifs.close();

    ( base::log() << "\n__________$ SolidProblem.h Restart() sendBoundaryRecievePressure() \n").flush();
    base::sendBoundaryReceivePressure();
    ( base::log() << "\n__________$ SolidProblem.h Restart() sendBoundaryRecievePressure() complete \n").flush();
  }

  virtual void Checkpointing() {
    MotionSolverbase::Checkpointing();
#ifdef CHECKRESTART_DEBUG_ON
    ( base::log() << "\nCHECKPOINTING Solid Problem " << std::endl ).flush();
#endif
    char fname[256];
    sprintf(fname,"%s.cp",CheckpointName.c_str());
    std::ofstream ofs(fname, std::ios::app);

    ( base::log() << "\n+++ CHECKPOINTING Solid Problem begun : appending at pos = " << ofs.tellp() << std::endl ).flush();

    ( base::log() << " num_turbines = " << num_turbines << std::endl ).flush();
    for (register int i=0; i < num_turbines; i++) {
      Turbines[i].Checkpointing(ofs);
    }
    Topology.Checkpointing(ofs);


#ifdef CHECKRESTART_DEBUG_ON
    ( base::log() << "\n+++ CHECKPOINTING Solid Problem COMPLETE pos = " << ofs.tellp() << std::endl ).flush();
#endif
    ofs.close();
  }

  int num_turbines;
  Turbine Turbines[MAX_TURBINES];
  TurbineControl TurbineCtrls[MAX_TURBINES];

  bool prescribed;

  Terrain Topology;
  TerrainControl TerrainCtrl;
  ControlDevice SLocCtrl;

  std::string SceneName;
};

class SolidSolverObjects {
public:
  SolidSolverObjects() {
    _MotionSpecific = new MotionSpecific();
  }

  ~SolidSolverObjects() {
    delete _MotionSpecific;
  }

protected:
  MotionSpecific *_MotionSpecific;
};

class SolidSolverSpecific : protected SolidSolverObjects, public MotionSpecific {
  typedef MotionSpecific base;
public:
  SolidSolverSpecific() : SolidSolverObjects(), base() {}

  ~SolidSolverSpecific() {
    delete _MotionSpecific;
    _MotionSpecific = (base *) 0;
  }

};


#endif

---