#include "mbconfig.h"
#include "mbdefs.h"
#include <cstdlib>
#include <cstring>
#include <limits>
#include <ac/unistd.h>
#include <cerrno>
#include <csignal>
#include <cfloat>
#include <cmath>
#include <vector>
#include <algorithm>
#include "ac/sys_sysinfo.h"
#include "solver.h"
#include "dataman.h"
#include "mtdataman.h"
#include "thirdorderstepsol.h"
#include "nr.h"
#include "linesearch.h"
#include "bicg.h"
#include "gmres.h"
#include "solman.h"
#include "readlinsol.h"
#include "ls.h"
#include "naivewrap.h"
#include "Rot.hh"
#include "cleanup.h"
#include "drive_.h"
#include "TimeStepControl.h"
#include "solver_impl.h"
#include "ac/lapack.h"
#include "ac/arpack.h"
#include "eigjdqz.h"

Include dependency graph for solver.cc:

Functions
int	mbdyn_stop_at_end_of_iteration (void)

int	mbdyn_stop_at_end_of_time_step (void)

void	mbdyn_set_stop_at_end_of_iteration (void)

void	mbdyn_set_stop_at_end_of_time_step (void)

void	mbdyn_signal_init (int pre)

int	mbdyn_reserve_stack (unsigned long size)

static int	do_eig (const doublereal &b, const doublereal &re, const doublereal &im, const doublereal &h, doublereal &sigma, doublereal &omega, doublereal &csi, doublereal &freq)

static void	output_eigenvalues (const VectorHandler pBeta, const VectorHandler &R, const VectorHandler &I, const doublereal &dShiftR, DataManager pDM, const Solver::EigenAnalysis *pEA, integer iLow, integer iHigh, std::vector< bool > &vOut)

Function Documentation

static int do_eig	(	const doublereal &	b,
		const doublereal &	re,
		const doublereal &	im,
		const doublereal &	h,
		doublereal &	sigma,
		doublereal &	omega,
		doublereal &	csi,
		doublereal &	freq
	)

static

Definition at line 3922 of file solver.cc.

References copysign(), M_PI, and grad::sqrt().

Referenced by output_eigenvalues().

 {
         // denominator
         doublereal d = re + b;
         d *= d;
         d += im*im;
         d *= h/2.;
 
         // real & imag
         sigma = (re*re - b*b + im*im)/d;
         omega = 2.*b*im/d;
 
         // frequency and damping factor
         if (im != 0.) {
                 d = sigma*sigma + omega*omega;
                 if (d > std::numeric_limits<doublereal>::epsilon()) {
                         csi = -100*sigma/sqrt(d);
 
                 } else {
                         csi = 0.;
                 }
 
                 freq = omega/(2*M_PI);
 
         } else {
                 if (std::abs(sigma) < std::numeric_limits<doublereal>::epsilon()) {
                         csi = 0.;
 
                 } else {
                         csi = -100.*copysign(1, sigma);
                 }
 
                 freq = 0.;
         }
 
         return 0;
 }

Here is the call graph for this function:

int mbdyn_reserve_stack ( unsigned long size )

Definition at line 254 of file solver.cc.

References buf.

Referenced by RTSolverBase::Init().

 {
         int buf[size];
 
 #ifdef HAVE_MEMSET
         memset(buf, 0, size*sizeof(int));
 #else /* !HAVE_MEMSET */
         for (unsigned long i = 0; i < size; i++) {
                 buf[i] = 0;
         }
 #endif /* !HAVE_MEMSET */
 
 #ifdef HAVE_MLOCKALL
         return mlockall(MCL_CURRENT | MCL_FUTURE);
 #else /* !HAVE_MLOCKALL */
         return 0;
 #endif /* !HAVE_MLOCKALL */
 }

void mbdyn_set_stop_at_end_of_iteration ( void )

Definition at line 192 of file solver.cc.

 {
 #ifdef HAVE_SIGNAL
         ::mbdyn_keep_going = MBDYN_STOP_AT_END_OF_ITERATION;
 #endif // HAVE_SIGNAL
 }

void mbdyn_set_stop_at_end_of_time_step ( void )

Definition at line 200 of file solver.cc.

Referenced by InverseSolver::Advance(), LoadIncNorm::AfterConvergence(), and ExtFileHandlerEDGE::Recv_pre().

 {
 #ifdef HAVE_SIGNAL
         ::mbdyn_keep_going = MBDYN_STOP_AT_END_OF_TIME_STEP;
 #endif // HAVE_SIGNAL
 }

void mbdyn_signal_init ( int pre )

Definition at line 208 of file solver.cc.

Referenced by InverseSolver::Prepare(), and Solver::Prepare().

 {
 #ifdef HAVE_SIGNAL
 #if defined(__FreeBSD__)
         __sighandler_t *hdl;
 #else // ! defined(__FreeBSD__)
         __sighandler_t hdl;
 #endif // ! defined(__FreeBSD__)
 
         if (pre) {
                 hdl = mbdyn_really_exit_handler;
 
         } else {
                 hdl = mbdyn_modify_final_time_handler;
         }
         /*
          * FIXME: don't do this if compiling with USE_RTAI
          * Re FIXME: use sigaction() ...
          */
         ::mbdyn_sh_term = signal(SIGTERM, hdl);
         if (::mbdyn_sh_term == SIG_IGN) {
                 signal(SIGTERM, SIG_IGN);
         }
 
         ::mbdyn_sh_int = signal(SIGINT, hdl);
         if (::mbdyn_sh_int == SIG_IGN) {
                 signal(SIGINT, SIG_IGN);
         }
 
 #ifdef SIGHUP
         ::mbdyn_sh_hup = signal(SIGHUP, hdl);
         if (::mbdyn_sh_hup == SIG_IGN) {
                 signal(SIGHUP, SIG_IGN);
         }
 #endif // SIGHUP
 
 #ifdef SIGPIPE
         ::mbdyn_sh_pipe = signal(SIGPIPE, hdl);
         if (::mbdyn_sh_pipe == SIG_IGN) {
                 signal(SIGPIPE, SIG_IGN);
         }
 #endif // SIGPIPE
 #endif /* HAVE_SIGNAL */
 }

int mbdyn_stop_at_end_of_iteration ( void )

Definition at line 172 of file solver.cc.

Referenced by ExtFileHandlerEDGE::CheckFlag(), LineSearchSolver::LineSearch(), ExtFileHandlerEDGE::Recv_pre(), ExtFileHandler::Recv_pre(), ExtFileHandlerEDGE::Send_pre(), ExtFileHandler::Send_pre(), ExtFileHandlerEDGE::SendFlag(), BiCGStab::Solve(), NewtonRaphsonSolver::Solve(), and Gmres::Solve().

 {
 #ifdef HAVE_SIGNAL
         return ::mbdyn_keep_going >= MBDYN_STOP_AT_END_OF_ITERATION;
 #else // ! HAVE_SIGNAL
         return 0;
 #endif // ! HAVE_SIGNAL
 }

int mbdyn_stop_at_end_of_time_step ( void )

Definition at line 182 of file solver.cc.

Referenced by InverseSolver::Advance(), Solver::Advance(), InverseSolver::Prepare(), Solver::Prepare(), and Solver::Start().

 {
 #ifdef HAVE_SIGNAL
         return ::mbdyn_keep_going >= MBDYN_STOP_AT_END_OF_TIME_STEP;
 #else // ! HAVE_SIGNAL
         return 0;
 #endif // ! HAVE_SIGNAL
 }

static void output_eigenvalues	(	const VectorHandler *	pBeta,
		const VectorHandler &	R,
		const VectorHandler &	I,
		const doublereal &	dShiftR,
		DataManager *	pDM,
		const Solver::EigenAnalysis *	pEA,
		integer	iLow,
		integer	iHigh,
		std::vector< bool > &	vOut
	)

static

Definition at line 3965 of file solver.cc.

References do_eig(), Solver::EigenAnalysis::dParam, Solver::EigenAnalysis::dUpperFreq, grad::fabs(), DataManager::GetOutFile(), VectorHandler::iGetSize(), and R.

 {
         std::ostream& Out = pDM->GetOutFile();
 
         /* Output? */
         Out << "Mode n. " "  " "    Real    " "   " "    Imag    " "  " "    " "   Damp %   " "  Freq Hz" << std::endl;
 
         integer iNVec = R.iGetSize();
 
         for (int iCnt = 1; iCnt <= iNVec; iCnt++) {
                 doublereal b = pBeta ? (*pBeta)(iCnt) : 1.;
                 doublereal re = R(iCnt) + dShiftR;
                 doublereal im = I(iCnt);
                 doublereal sigma;
                 doublereal omega;
                 doublereal csi;
                 doublereal freq;
 
                 if (iCnt < iLow || iCnt > iHigh) {
                         vOut[iCnt - 1] = false;
                         continue;
                 }
 
                 const doublereal& h = pEA->dParam;
                 do_eig(b, re, im, h, sigma, omega, csi, freq);
 
                 if (freq < pEA->dLowerFreq || freq > pEA->dUpperFreq) {
                         vOut[iCnt - 1] = false;
                         continue;
                 }
 
                 vOut[iCnt - 1] = true;
 
                 Out << std::setw(8) << iCnt << ": "
                         << std::setw(12) << sigma << " + " << std::setw(12) << omega << " j";
 
                 if (fabs(csi) > std::numeric_limits<doublereal>::epsilon()) {
                         Out << "    " << std::setw(12) << csi;
                 } else {
                         Out << "    " << std::setw(12) << 0.;
                 }
 
                 Out << "    " << std::setw(12) << freq;
 
                 Out << std::endl;
         }
 }

Here is the call graph for this function:

Functions

Function Documentation