BeamCoupledSolver2.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, ralf@amroc.net

#ifndef BEAM_COUPLED_SOLVER2_H
#define BEAM_COUPLED_SOLVER2_H

#include <cmath>
#include "BeamSolver.h"

template <>
class BeamCoupledSolver<2> : public BeamSolver {
  typedef BeamSolver base;
public:
  BeamCoupledSolver() : base(), nodeids(0), connections(0), coordinates(0), 
                        velocities(0) {}
  virtual ~BeamCoupledSolver() {}

  //******************************************************************************
  // Abstract class interface
  //******************************************************************************
  virtual void sendBoundaryReceivePressure() = 0;  
  //******************************************************************************

  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    base::register_at(Ctrl,prefix);
    char VariableName[32];
    for (int d=0; d<2; d++) {
      std::sprintf(VariableName,"Start(%d)",d+1);
      RegisterAt(base::LocCtrl,VariableName,start[d]);
      std::sprintf(VariableName,"Tangent(%d)",d+1);
      RegisterAt(base::LocCtrl,VariableName,tangent[d]);
    }
  }
  virtual void register_at(ControlDevice& Ctrl) {
    register_at(Ctrl, "");
  }

  virtual bool setup() {
    bool ret=base::setup();
    if (ret) {
      nodeids = new int[NumNodes()];
      for (register int i=0; i<NumNodes(); i++)
        nodeids[i] = i;
      connections = new int[2*NumElements()]; 
      for (register int i=0; i<NumElements(); i++) {
        connections[2*i] = i; connections[2*i+1] = i+1;
      } 
      coordinates = new double[2*NumNodes()];
      velocities = new double[2*NumNodes()];
    }
    return ret;
  }

  virtual void finish() {
    base::finish();
    if (nodeids) delete [] nodeids;
    if (connections) delete [] connections;
    if (coordinates) delete [] coordinates;
    if (velocities) delete [] velocities;
  } 

  virtual void Initialize(double& t, double& dt) {
    base::Initialize(t,dt);
    sendBoundaryReceivePressure();
  }

  virtual void Advance(double& t, double& dt) {
    sendBoundaryReceivePressure();
    base::Advance(t,dt);
  }

  virtual void Restart(double& t, double& dt) {
    base::Restart(t,dt);
    sendBoundaryReceivePressure();
  }

  virtual void UpdateBoundary() {
    double alpha=0;
    if (tangent[0]!=0.) alpha=std::atan(tangent[1]/tangent[0]);
    else {
      if (tangent[1]>0) alpha=2.*std::atan(1.0);
      else alpha=-2.*std::atan(1.0);
    }
    double ca = std::cos(alpha);
    double sa = std::sin(alpha);
    for (register int i=0; i<NumNodes(); i++) {
      coordinates[2*i]   = start[0] + ca*i*base::StepSize() - 
        sa*base::Deflection(i);  
      coordinates[2*i+1] = start[1] + sa*i*base::StepSize() +
        ca*base::Deflection(i);  
      velocities[2*i]   = -sa*base::Velocity(i);
      velocities[2*i+1] =  ca*base::Velocity(i);      
    } 
  }
    
  inline int NumNodes() { return base::NumNodes(); }
  inline int NumElements() { return base::NumNodes()-1; }
  inline double* Pressures() { return base::CurLoad(); }
  inline const int* NodeIDs() const { return nodeids; }
  inline const int* Connections() const { return connections; }
  inline const double* Coordinates() const { return coordinates; }
  inline const double* Velocities() const { return velocities; }
  
protected:
  double start[2];
  double tangent[2];
  int* nodeids;
  int* connections;
  double* coordinates;
  double* velocities;
};
  
#endif

---