fsi/motion-amroc/HingedWing/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_WINGS 2

//#define MOTION_DEBUG_ON

#include "MotionSolver.h"
#include "MotionELCCoupledSolver.h"
#include "WingMechanism.h"

class MotionSpecific : public MotionELCCoupledSolver<DataType,DIM> {
  typedef MotionELCCoupledSolver<DataType,DIM> base;
  typedef MotionSolver<DataType,DIM> MotionSolverbase;
public:
  MotionSpecific() : base() {
    num_wings = 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,"OutputName",OutputName);
    RegisterAt(SLocCtrl,"CheckpointName",CheckpointName);

    RegisterAt(SLocCtrl,"Scale",scale);

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

    RegisterAt(SLocCtrl,"SceneName",SceneName);
    RegisterAt(SLocCtrl,"SAtimeStep",base::SAL);

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

  }

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

    for (register int i = 0; i < num_wings; i++) {
#ifdef MOTION_DEBUG_ON
      ( base::log() << "SolidProblem.h WingCtrls[" << i << "].comp0_name = " << WingCtrls[i].comp0_name << std::endl ).flush();
#endif
      ( base::log() << "SolidProblem.h WingCtrls[" << i << "].comp0_name = " << WingCtrls[i].comp0_name << std::endl ).flush();
      Wings[i].specificSetup(_Scene(),&WingCtrls[i]);
    }
    //std::cout << " yup\n";
    _Scene().printSummary();
    //std::cout << " yup1\n";
#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();

    for (int i = 0; i < _Scene().GetNumAssemblies(); i ++) {
      ( base::log() << "\nASSEMBLY " << i << std::endl).flush();
      _Scene().GetNthAssembly(i)->print(0);
    }

    ( base::log() << " _Scene().GetNumChains() = " << _Scene().GetNumChains() << std::endl).flush();
    for (int i = 0; i < _Scene().GetNumChains(); i ++) {
      ( base::log() << "\nCHAIN " << i << std::endl).flush();
      if (_Scene().GetNthChain(i)->getParentChain() <= 0) {
        _Scene().GetNthChain(i)->print(_Scene(),1);
      }
      else {
        _Scene().GetNthChain(i)->print(_Scene(),2);
      }
    }
#endif

    for (register int i = 0; i < num_wings; i++) {
#ifdef MOTION_DEBUG_ON
      ( base::log() << "SolidProblem.h WingCtrls[" << i << "].comp0_name = " << WingCtrls[i].comp0_name << std::endl ).flush();
#endif
      if (prescribed == 1) {
        Wings[i].movement(&Wings[i],&WingCtrls[i], t, dt);
      }
      else {
        Wings[i].response(&Wings[i],&WingCtrls[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_wings; i++) {
      Wings[i].logKinetics(&Wings[i],&WingCtrls[i], ofs, MotionSolverbase::CurrentTime(), MotionSolverbase::NSteps());
      if (i<num_wings-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_wings = " << num_wings << std::endl ).flush();
    for (register int i=0; i < num_wings; i++) {
      Wings[i].Restart(ifs,pos,t,dt);
      pos = ifs.tellg();
    }
    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_wings = " << num_wings << std::endl ).flush();
    for (register int i=0; i < num_wings; i++) {
      Wings[i].Checkpointing(ofs);
    }

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

  int num_wings;
  Wing Wings[MAX_WINGS];
  WingControl WingCtrls[MAX_WINGS];

  bool prescribed;

  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

---