#include <output.h>

Inheritance diagram for OutputHandler:

Collaboration diagram for OutputHandler:

Public Types
enum	OutFiles { UNKNOWN = -1, FIRSTFILE = 0, OUTPUT = 0, STRNODES, ELECTRIC, ABSTRACT, INERTIA, JOINTS, FORCES, BEAMS, ROTORS, RESTART, RESTARTXSOL, AERODYNAMIC, HYDRAULIC, PRESNODES, LOADABLE, GENELS, PARTITION, AEROMODALS, REFERENCEFRAMES, LOG, AIRPROPS, PARAMETERS, EXTERNALS, MODAL, NETCDF, THERMALNODES, THERMALELEMENTS, PLATES, GRAVITY, DOFSTATS, DRIVECALLERS, TRACES, EIGENANALYSIS, LASTFILE }

Public Member Functions
void	SetCurrentStep (long Step)

void	IncCurrentStep (void)

long	GetCurrentStep (void) const

	OutputHandler (void)

	OutputHandler (const char *sFName, int iExtNum=-1)

void	Init (const char *sFName, int iExtNum=-1)

virtual	~OutputHandler (void)

bool	Open (const OutputHandler::OutFiles out)

bool	Open (const int out, const std::string &postfix)

bool	IsOpen (const OutputHandler::OutFiles out) const

bool	UseDefaultPrecision (const OutputHandler::OutFiles out) const

bool	UseScientific (const OutputHandler::OutFiles out) const

void	SetText (const OutputHandler::OutFiles out)

void	ClearText (void)

void	ClearText (const OutputHandler::OutFiles out)

bool	UseText (const OutputHandler::OutFiles out) const

void	SetNetCDF (const OutputHandler::OutFiles out)

void	ClearNetCDF (void)

void	ClearNetCDF (const OutputHandler::OutFiles out)

bool	UseNetCDF (const OutputHandler::OutFiles out) const

bool	Close (const OutputHandler::OutFiles out)

bool	OutputOpen (void)

bool	RestartOpen (bool openResXSol=false)

bool	PartitionOpen (void)

bool	LogOpen (void)

std::ostream &	Get (const OutputHandler::OutFiles f)

std::ostream &	Output (void) const

std::ostream &	StrNodes (void) const

std::ostream &	Electric (void) const

std::ostream &	Abstract (void) const

std::ostream &	Inertia (void) const

std::ostream &	Joints (void) const

std::ostream &	Forces (void) const

std::ostream &	Beams (void) const

std::ostream &	Rotors (void) const

std::ostream &	Restart (void) const

std::ostream &	RestartXSol (void) const

std::ostream &	Aerodynamic (void) const

std::ostream &	Hydraulic (void) const

std::ostream &	PresNodes (void) const

std::ostream &	Loadable (void) const

std::ostream &	Genels (void) const

std::ostream &	Partition (void) const

std::ostream &	AeroModals (void) const

std::ostream &	ReferenceFrames (void) const

std::ostream &	Log (void) const

std::ostream &	AirProps (void) const

std::ostream &	Parameters (void) const

std::ostream &	Externals (void) const

std::ostream &	Modal (void) const

std::ostream &	ThermalNodes (void) const

std::ostream &	ThermalElements (void) const

std::ostream &	Plates (void) const

std::ostream &	Gravity (void) const

std::ostream &	DofStats (void) const

std::ostream &	DriveCallers (void) const

std::ostream &	Traces (void) const

std::ostream &	Eigenanalysis (void) const

int	iW (void) const

int	iP (void) const

void	SetWidth (int iNewWidth)

void	SetPrecision (int iNewPrecision)

void	SetExceptions (std::ios::iostate flags)

Public Member Functions inherited from FileName
	FileName (const char *n=NULL, int i=0)

virtual	~FileName (void)

int	iInit (const char *n, int i=0)

const char *const	_sPutExt (const char *n)

const char *const	sGet (void) const

Private Types
enum	{ OUTPUT_NONE = 0x00U, OUTPUT_USE_DEFAULT_PRECISION = 0x01U, OUTPUT_USE_SCIENTIFIC = 0x02U, OUTPUT_MAY_USE_TEXT = 0x10U, OUTPUT_USE_TEXT = 0x20U, OUTPUT_MAY_USE_NETCDF = 0x40U, OUTPUT_USE_NETCDF = 0x80U, LAST }

Private Member Functions
bool	IsOpen (int out) const

bool	UseDefaultPrecision (int out) const

bool	UseScientific (int out) const

bool	UseText (int out) const

bool	UseNetCDF (int out) const

void	OutputHandler_int (void)

Private Attributes
long	currentStep

struct {
std::ofstream * pof

unsigned flags

}	OutData [LASTFILE]

std::ofstream	ofOutput

std::ofstream	ofStrNodes

std::ofstream	ofElectric

std::ofstream	ofAbstract

std::ofstream	ofInertia

std::ofstream	ofJoints

std::ofstream	ofForces

std::ofstream	ofBeams

std::ofstream	ofRotors

std::ofstream	ofRestart

std::ofstream	ofRestartXSol

std::ofstream	ofAerodynamic

std::ofstream	ofHydraulic

std::ofstream	ofPresNodes

std::ofstream	ofLoadable

std::ofstream	ofGenels

std::ofstream	ofPartition

std::ofstream	ofAeroModals

std::ofstream	ofReferenceFrames

std::ofstream	ofLog

std::ofstream	ofAirProps

std::ofstream	ofParameters

std::ofstream	ofExternals

std::ofstream	ofModal

std::ofstream	ofThermalNodes

std::ofstream	ofThermalElements

std::ofstream	ofPlates

std::ofstream	ofGravity

std::ofstream	ofDofStats

std::ofstream	ofDriveCallers

std::ofstream	ofTraces

std::ofstream	ofEigenanalysis

int	iCurrWidth

int	iCurrPrecision

int	nCurrRestartFile

Detailed Description

Definition at line 65 of file output.h.

Member Enumeration Documentation

anonymous enum

private

Enumerator
OUTPUT_NONE
OUTPUT_USE_DEFAULT_PRECISION
OUTPUT_USE_SCIENTIFIC
OUTPUT_MAY_USE_TEXT
OUTPUT_USE_TEXT
OUTPUT_MAY_USE_NETCDF
OUTPUT_USE_NETCDF
LAST

Definition at line 123 of file output.h.

              {
                 OUTPUT_NONE                     = 0x00U,
                 OUTPUT_USE_DEFAULT_PRECISION    = 0x01U,
                 OUTPUT_USE_SCIENTIFIC           = 0x02U,
 
                 OUTPUT_MAY_USE_TEXT             = 0x10U,
                 OUTPUT_USE_TEXT                 = 0x20U,
                 OUTPUT_MAY_USE_NETCDF           = 0x40U,
                 OUTPUT_USE_NETCDF               = 0x80U,
 
                 LAST
         };

enum OutputHandler::OutFiles

Enumerator
UNKNOWN
FIRSTFILE
OUTPUT
STRNODES
ELECTRIC
ABSTRACT
INERTIA
JOINTS
FORCES
BEAMS
ROTORS
RESTART
RESTARTXSOL
AERODYNAMIC
HYDRAULIC
PRESNODES
LOADABLE
GENELS
PARTITION
AEROMODALS
REFERENCEFRAMES
LOG
AIRPROPS
PARAMETERS
EXTERNALS
MODAL
NETCDF
THERMALNODES
THERMALELEMENTS
PLATES
GRAVITY
DOFSTATS
DRIVECALLERS
TRACES
EIGENANALYSIS
LASTFILE

Definition at line 67 of file output.h.

                       {
                 UNKNOWN                 = -1,
                 FIRSTFILE               = 0,
                 OUTPUT                  = 0,    //  0
                 STRNODES,
                 ELECTRIC,
                 ABSTRACT,
                 INERTIA,
                 JOINTS,                         //  5
                 FORCES,
                 BEAMS,
                 ROTORS,
                 RESTART,
                 RESTARTXSOL,                    // 10
                 AERODYNAMIC,
                 HYDRAULIC,
                 PRESNODES,
                 LOADABLE,
                 GENELS,                         // 15
                 PARTITION,
                 AEROMODALS,
                 REFERENCEFRAMES,
                 LOG,
                 AIRPROPS,                       // 20
                 PARAMETERS,
                 EXTERNALS,
                 MODAL,
                 NETCDF,
                 THERMALNODES,                   // 25
                 THERMALELEMENTS,
                 PLATES,
                 GRAVITY,
                 DOFSTATS,
                 DRIVECALLERS,                   // 30
                 TRACES,
                 EIGENANALYSIS,                  // NOTE: ALWAYS LAST!
                 LASTFILE                        // 33
         };

Constructor & Destructor Documentation

OutputHandler::OutputHandler ( void )

Definition at line 87 of file output.cc.

References OutputHandler_int().

 : FileName(NULL),
 #ifdef USE_NETCDF
 m_DimTime(0),
 m_DimV1(0),
 m_DimV3(0),
 m_pBinFile(0),
 #endif /* USE_NETCDF */
 iCurrWidth(iDefaultWidth),
 iCurrPrecision(iDefaultPrecision),
 nCurrRestartFile(0)
 {
         OutputHandler_int();
 }

Here is the call graph for this function:

OutputHandler::OutputHandler	(	const char *	sFName,
		int	iExtNum = `-1`
	)

Definition at line 103 of file output.cc.

References Init(), and OutputHandler_int().

 : FileName(sFName, iExtNum),
 #ifdef USE_NETCDF
 m_DimTime(0),
 m_DimV1(0),
 m_DimV3(0),
 m_pBinFile(0),
 #endif /* USE_NETCDF */
 iCurrWidth(iDefaultWidth),
 iCurrPrecision(iDefaultPrecision),
 nCurrRestartFile(0)
 {
         OutputHandler_int();
         Init(sFName, iExtNum);
 }

Here is the call graph for this function:

OutputHandler::~OutputHandler ( void )

virtual

Definition at line 276 of file output.cc.

References IsOpen(), LASTFILE, NETCDF, and OutData.

 {
         for (int iCnt = 0; iCnt < LASTFILE; iCnt++) {
                 if (IsOpen(iCnt)) {
 #ifdef USE_NETCDF
                         if (iCnt == NETCDF) {
                                 if (m_pBinFile != 0) {
                                         delete m_pBinFile;
                                 }
 
                         } else
 #endif /* USE_NETCDF */
                         {
                                 OutData[iCnt].pof->exceptions(std::ios::iostate(0));
                                 OutData[iCnt].pof->close();
                         }
                 }
         }
 }

Here is the call graph for this function:

Member Function Documentation

std::ostream & OutputHandler::Abstract ( void ) const

inline

Definition at line 429 of file output.h.

References ABSTRACT, ASSERT, IsOpen(), and ofAbstract.

Referenced by ScalarNode::Output().

 {
         ASSERT(IsOpen(ABSTRACT));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofAbstract));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Aerodynamic ( void ) const

inline

Definition at line 485 of file output.h.

References AERODYNAMIC, ASSERT, IsOpen(), and ofAerodynamic.

Referenced by AircraftInstruments::Output(), GenericAerodynamicForce::Output(), AerodynamicBody::Output(), AerodynamicBeam::Output(), and AerodynamicBeam2::Output().

 {
         ASSERT(IsOpen(AERODYNAMIC));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofAerodynamic));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::AeroModals ( void ) const

inline

Definition at line 527 of file output.h.

References AEROMODALS, ASSERT, IsOpen(), and ofAeroModals.

Referenced by AerodynamicModal::Output().

 {
         ASSERT(IsOpen(AEROMODALS));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofAeroModals));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::AirProps ( void ) const

inline

Definition at line 552 of file output.h.

References AIRPROPS, ASSERT, IsOpen(), and ofAirProps.

Referenced by AirProperties::Output().

 {
         ASSERT(IsOpen(AIRPROPS));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofAirProps));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Beams ( void ) const

inline

Definition at line 457 of file output.h.

References ASSERT, BEAMS, IsOpen(), and ofBeams.

Referenced by HBeam::Output(), Beam2::Output(), and Beam::Output().

 {
         ASSERT(IsOpen(BEAMS));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofBeams));
 }

Here is the call graph for this function:

void OutputHandler::ClearNetCDF ( void )

Definition at line 510 of file output.cc.

References FIRSTFILE, flags, LASTFILE, OutData, OUTPUT_MAY_USE_NETCDF, and OUTPUT_USE_NETCDF.

 {
         for (int out = FIRSTFILE; out < LASTFILE; out++) {
                 if (OutData[out].flags & OUTPUT_MAY_USE_NETCDF) {
                         OutData[out].flags &= ~OUTPUT_USE_NETCDF;
                 }
         }
 }

void OutputHandler::ClearNetCDF ( const OutputHandler::OutFiles out )

Definition at line 520 of file output.cc.

References flags, MBDYN_EXCEPT_ARGS, OutData, OUTPUT_MAY_USE_NETCDF, and OUTPUT_USE_NETCDF.

 {
         if (!(OutData[out].flags & OUTPUT_MAY_USE_NETCDF)) {
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         OutData[out].flags &= ~OUTPUT_USE_NETCDF;
 }

void OutputHandler::ClearText ( void )

Definition at line 465 of file output.cc.

References FIRSTFILE, flags, LASTFILE, OutData, OUTPUT_MAY_USE_TEXT, and OUTPUT_USE_TEXT.

Referenced by DataManager::ReadControl().

 {
         for (int out = FIRSTFILE; out < LASTFILE; out++) {
                 if (OutData[out].flags & OUTPUT_MAY_USE_TEXT) {
                         OutData[out].flags &= ~OUTPUT_USE_TEXT;
                 }
         }
 }

void OutputHandler::ClearText ( const OutputHandler::OutFiles out )

Definition at line 475 of file output.cc.

References flags, MBDYN_EXCEPT_ARGS, OutData, OUTPUT_MAY_USE_TEXT, and OUTPUT_USE_TEXT.

 {
         if (!(OutData[out].flags & OUTPUT_MAY_USE_TEXT)) {
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         OutData[out].flags &= ~OUTPUT_USE_TEXT;
 }

bool OutputHandler::Close ( const OutputHandler::OutFiles out )

Definition at line 536 of file output.cc.

References IsOpen(), NETCDF, and OutData.

Referenced by DataManager::MakeRestart(), and DataManager::OutputEigClose().

 {
         if (!IsOpen(out)) {
                 return false;
         }
 
 #ifdef USE_NETCDF
         if (out == NETCDF) {
                 m_pBinFile->close();
 
         } else
 #endif /* USE_NETCDF */
         {
                 // Chiude lo stream
                 OutData[out].pof->close();
         }
 
         return true;
 }

Here is the call graph for this function:

std::ostream & OutputHandler::DofStats ( void ) const

inline

Definition at line 594 of file output.h.

References ASSERT, DOFSTATS, IsOpen(), and ofDofStats.

Referenced by DataManager::DofOwnerInit(), and DataManager::InitialJointAssembly().

 {
         ASSERT(IsOpen(DOFSTATS));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofDofStats));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::DriveCallers ( void ) const

inline

Definition at line 601 of file output.h.

References ASSERT, DRIVECALLERS, IsOpen(), and ofDriveCallers.

Referenced by DriveCaller::Output().

 {
         ASSERT(IsOpen(DRIVECALLERS));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofDriveCallers));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Eigenanalysis ( void ) const

inline

Definition at line 615 of file output.h.

References ASSERT, EIGENANALYSIS, IsOpen(), and ofEigenanalysis.

Referenced by DataManager::OutputEigenvectors(), DataManager::OutputEigFullMatrices(), DataManager::OutputEigGeometry(), DataManager::OutputEigNaiveMatrices(), DataManager::OutputEigParams(), and DataManager::OutputEigSparseMatrices().

 {
         ASSERT(IsOpen(EIGENANALYSIS));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofEigenanalysis));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Electric ( void ) const

inline

Definition at line 408 of file output.h.

References ASSERT, ELECTRIC, IsOpen(), and ofElectric.

Referenced by ElectricNode::Output().

 {
         ASSERT(IsOpen(ELECTRIC));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofElectric));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Externals ( void ) const

inline

Definition at line 566 of file output.h.

References ASSERT, EXTERNALS, IsOpen(), and ofExternals.

 {
         ASSERT(IsOpen(EXTERNALS));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofExternals));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Forces ( void ) const

inline

Definition at line 450 of file output.h.

References ASSERT, FORCES, IsOpen(), and ofForces.

Referenced by ModalForce::Output(), AbsoluteDispForce::Output(), ModalMappingExt::Output(), StructExtForce::Output(), StructMappingExtForce::Output(), AbsoluteInternalDispForce::Output(), AbstractForce::Output(), ModalExt::Output(), AbstractInternalForce::Output(), AbsoluteForce::Output(), FollowerForce::Output(), AbsoluteCouple::Output(), FollowerCouple::Output(), AbsoluteInternalForce::Output(), TotalForce::Output(), FollowerInternalForce::Output(), AbsoluteInternalCouple::Output(), and FollowerInternalCouple::Output().

 {
         ASSERT(IsOpen(FORCES));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofForces));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Genels ( void ) const

inline

Definition at line 513 of file output.h.

References ASSERT, GENELS, IsOpen(), and ofGenels.

Referenced by GenelClamp::Output(), GenelStateSpaceSISO::Output(), GenelDistance::Output(), and GenelStateSpaceMIMO::Output().

 {
         ASSERT(IsOpen(GENELS));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofGenels));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Get ( const OutputHandler::OutFiles f )

inline

Definition at line 382 of file output.h.

References ASSERT, IsOpen(), LASTFILE, and OutData.

Referenced by ThermalNode::Output().

 {
         ASSERT(f > -1 && f < LASTFILE);
         ASSERT(IsOpen(f));
         return *(OutData[f].pof);
 }

Here is the call graph for this function:

long OutputHandler::GetCurrentStep ( void ) const

inline

Definition at line 116 of file output.h.

References currentStep.

Referenced by AbsoluteDispForce::Output(), InLineJoint::Output(), PrismaticJoint::Output(), SphericalHingeJoint::Output(), DeformableDispJoint::Output(), DeformableHingeJoint::Output(), DeformableJoint::Output(), Rod::Output(), Inertia::Output(), AbsoluteInternalDispForce::Output(), AutomaticStructDispElem::Output(), PlaneHingeJoint::Output(), UniversalRotationJoint::Output(), TotalJoint::Output(), StructDispNode::Output(), AbsoluteForce::Output(), Beam2::Output(), AutomaticStructElem::Output(), PlaneRotationJoint::Output(), Wheel4::Output(), FollowerForce::Output(), Beam::Output(), AbsoluteCouple::Output(), DataManager::Output(), TotalPinJoint::Output(), FollowerCouple::Output(), AxialRotationJoint::Output(), AbsoluteInternalForce::Output(), FollowerInternalForce::Output(), AbsoluteInternalCouple::Output(), FollowerInternalCouple::Output(), StructNode::Output(), Aerodynamic2DElem< iNN >::Output_int(), and DataManager::OutputEigParams().

                                                {
                 return currentStep;
         };

std::ostream & OutputHandler::Gravity ( void ) const

inline

Definition at line 587 of file output.h.

References ASSERT, GRAVITY, IsOpen(), and ofGravity.

Referenced by UniformGravity::Output(), and CentralGravity::Output().

 {
         ASSERT(IsOpen(GRAVITY));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofGravity));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Hydraulic ( void ) const

inline

Definition at line 492 of file output.h.

References ASSERT, HYDRAULIC, IsOpen(), and ofHydraulic.

Referenced by MinorLoss::Output(), Pipe::Output(), Control_valve::Output(), Actuator::Output(), Accumulator::Output(), ThreeWayMinorLoss::Output(), Dynamic_pipe::Output(), Tank::Output(), Control_valve2::Output(), Orifice::Output(), DynamicPipe::Output(), Dynamic_control_valve::Output(), Pressure_flow_control_valve::Output(), Pressure_valve::Output(), and Flow_valve::Output().

 {
         ASSERT(IsOpen(HYDRAULIC));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofHydraulic));
 }

Here is the call graph for this function:

void OutputHandler::IncCurrentStep ( void )

inline

Definition at line 113 of file output.h.

References currentStep.

Referenced by DataManager::Output().

                                          {
                 currentStep++;
         };

std::ostream & OutputHandler::Inertia ( void ) const

inline

Definition at line 436 of file output.h.

References ASSERT, INERTIA, IsOpen(), and ofInertia.

Referenced by AutomaticStructDispElem::Output(), and AutomaticStructElem::Output().

 {
         ASSERT(IsOpen(INERTIA));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofInertia));
 }

Here is the call graph for this function:

void OutputHandler::Init	(	const char *	sFName,
		int	iExtNum = `-1`
	)

Definition at line 267 of file output.cc.

References FileName::iInit(), LogOpen(), and OutputOpen().

Referenced by OutputHandler().

 {
         FileName::iInit(sFName, iExtNum);
 
         OutputOpen();
         LogOpen();
 }

Here is the call graph for this function:

int OutputHandler::iP ( void ) const

inline

Definition at line 629 of file output.h.

References iCurrPrecision.

 {
         return iCurrPrecision;
 }

bool OutputHandler::IsOpen ( int out ) const

private

Definition at line 395 of file output.cc.

References ASSERT, LASTFILE, and UNKNOWN.

Referenced by Abstract(), Aerodynamic(), AeroModals(), AirProps(), Beams(), Close(), DofStats(), DriveCallers(), DataManager::DriveOutput(), DataManager::DriveTrace(), Eigenanalysis(), Electric(), DataManager::ElemOutputPrepare(), Externals(), Forces(), Genels(), Get(), Gravity(), Hydraulic(), Inertia(), Joints(), Loadable(), Log(), LogOpen(), Modal(), DataManager::NodeOutputPrepare(), Open(), Output(), DataManager::OutputEigOpen(), DataManager::OutputOpen(), AbsoluteDispForce::OutputPrepare(), AbsoluteInternalDispForce::OutputPrepare(), AutomaticStructDispElem::OutputPrepare(), Aerodynamic2DElem< iNN >::OutputPrepare(), StructDispNode::OutputPrepare(), Beam2::OutputPrepare(), AbsoluteForce::OutputPrepare(), AutomaticStructElem::OutputPrepare(), Wheel4::OutputPrepare(), FollowerForce::OutputPrepare(), Beam::OutputPrepare(), AbsoluteCouple::OutputPrepare(), DataManager::OutputPrepare(), FollowerCouple::OutputPrepare(), AbsoluteInternalForce::OutputPrepare(), FollowerInternalForce::OutputPrepare(), AbsoluteInternalCouple::OutputPrepare(), FollowerInternalCouple::OutputPrepare(), StructNode::OutputPrepare(), Joint::OutputPrepare_int(), Inertia::OutputPrepare_int(), Parameters(), Partition(), PartitionOpen(), Plates(), PresNodes(), ReferenceFrames(), Restart(), RestartOpen(), RestartXSol(), Rotors(), SetPrecision(), SetWidth(), StrNodes(), ThermalElements(), ThermalNodes(), Traces(), and ~OutputHandler().

 {
         ASSERT(out > OutputHandler::UNKNOWN);
         ASSERT(out < OutputHandler::LASTFILE);
 
         return IsOpen(OutputHandler::OutFiles(out));
 }

bool OutputHandler::IsOpen ( const OutputHandler::OutFiles out ) const

Definition at line 404 of file output.cc.

References NETCDF, and OutData.

 {
 #ifdef USE_NETCDF
         if (out == NETCDF) {
                 return m_pBinFile == 0 ? false : m_pBinFile->is_valid();
         }
 #endif /* USE_NETCDF */
 
         return OutData[out].pof == 0 ? false : OutData[out].pof->is_open();
 }

int OutputHandler::iW ( void ) const

inline

Definition at line 623 of file output.h.

References iCurrWidth.

 {
         return iCurrWidth;
 }

std::ostream & OutputHandler::Joints ( void ) const

inline

Definition at line 443 of file output.h.

References ASSERT, IsOpen(), JOINTS, and ofJoints.

Referenced by GimbalRotationJoint::Output(), LinearAccelerationJoint::Output(), DriveDisplacementJoint::Output(), DriveHingeJoint::Output(), ViscousBody::Output(), LinearVelocityJoint::Output(), InLineJoint::Output(), DistanceJoint::Output(), UniversalHingeJoint::Output(), PrismaticJoint::Output(), SphericalHingeJoint::Output(), DeformableAxialJoint::Output(), InPlaneJoint::Output(), DeformableDispJoint::Output(), RodBezier::Output(), DeformableHingeJoint::Output(), DeformableJoint::Output(), Rod::Output(), Brake::Output(), AngularAccelerationJoint::Output(), PlaneHingeJoint::Output(), BeamSliderJoint::Output(), AngularVelocityJoint::Output(), InLineWithOffsetJoint::Output(), ContactJoint::Output(), DistanceJointWithOffset::Output(), UniversalRotationJoint::Output(), PinJoint::Output(), TotalEquation::Output(), InPlaneWithOffsetJoint::Output(), TotalJoint::Output(), DriveDisplacementPinJoint::Output(), UniversalPinJoint::Output(), PlaneRotationJoint::Output(), ClampJoint::Output(), TotalReaction::Output(), TotalPinJoint::Output(), AxialRotationJoint::Output(), PlanePinJoint::Output(), and DeformableHingeJoint::OutputInv().

 {
         ASSERT(IsOpen(JOINTS));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofJoints));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Loadable ( void ) const

inline

Definition at line 506 of file output.h.

References ASSERT, IsOpen(), LOADABLE, and ofLoadable.

Referenced by ModuleMDS::Output(), ModuleIMU::Output(), HydrodynamicPlainBearing::Output(), InlineFriction::Output(), LoadIncNorm::Output(), asynchronous_machine::Output(), ModuleFMU::Output(), CyclocopterInflow::Output(), Wheel2::Output(), ModuleNonsmoothNode::Output(), Wheel4::Output(), ModuleIMUConstraint::Output(), CyclocopterUniform1D::Output(), LoadIncForce::Output(), CyclocopterUniform2D::Output(), and CyclocopterPolimi::Output().

 {
         ASSERT(IsOpen(LOADABLE));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofLoadable));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Log ( void ) const

inline

Definition at line 541 of file output.h.

References ASSERT, IsOpen(), LOG, and ofLog.

Referenced by DataManager::DofOwnerInit(), DataManager::GetLogFile(), DataManager::ReadControl(), and DataManager::ReadOneElem().

 {
 #ifdef DEBUG_COUT
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(cout));
 #else
         ASSERT(IsOpen(LOG));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofLog));
 #endif
 }

Here is the call graph for this function:

bool OutputHandler::LogOpen ( void )

Definition at line 637 of file output.cc.

References ASSERT, IsOpen(), LOG, and Open().

Referenced by Init().

 {
         ASSERT(!IsOpen(LOG));
         return Open(LOG);
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Modal ( void ) const

inline

Definition at line 573 of file output.h.

References ASSERT, IsOpen(), MODAL, and ofModal.

Referenced by Modal::Output().

 {
         ASSERT(IsOpen(MODAL));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofModal));
 }

Here is the call graph for this function:

bool OutputHandler::Open ( const OutputHandler::OutFiles out )

Definition at line 298 of file output.cc.

References FileName::_sPutExt(), NcFile::Fill, iCurrPrecision, IsOpen(), MBDYN_EXCEPT_ARGS, NETCDF, OutData, pof, psExt, NcFile::Replace, UseDefaultPrecision(), UseScientific(), and UseText().

Referenced by DataManager::DataManager(), DataManager::DofOwnerInit(), DataManager::InitialJointAssembly(), LogOpen(), DataManager::OutputEigOpen(), OutputOpen(), DataManager::OutputOpen(), DataManager::OutputPrepare(), and PartitionOpen().

 {
 #ifdef USE_NETCDF
         if (out == NETCDF && !IsOpen(out)) {
                 m_pBinFile = new NcFile(_sPutExt((char*)(psExt[NETCDF])), NcFile::Replace);
                 m_pBinFile->set_fill(NcFile::Fill);
 
                 if (!m_pBinFile->is_valid()) {
                         silent_cerr("NetCDF file is invalid" << std::endl);
                         throw ErrFile(MBDYN_EXCEPT_ARGS);
                 }
 
                 // Let's define some dimensions which could be useful
                 m_DimTime = CreateDim("time");
                 m_DimV1 = CreateDim("vec1", 1);
                 m_DimV3 = CreateDim("vec3", 3);
 
         } else
 #endif /* USE_NETCDF */
         {
                 if (!IsOpen(out)) {
                         const char *fname = _sPutExt(psExt[out]);
 
                         // Apre lo stream
                         OutData[out].pof->open(fname);
 
                         if (!(*OutData[out].pof)) {
                                 silent_cerr("Unable to open file "
                                         "\"" << fname << "\"" << std::endl);
                                 throw ErrFile(MBDYN_EXCEPT_ARGS);
                         }
 
                         if (UseText(out)) {
                                 // Setta la formattazione dei campi
                                 if (UseDefaultPrecision(out)) {
                                         OutData[out].pof->precision(iCurrPrecision);
                                 }
 
                                 // Setta la notazione
                                 if (UseScientific(out)) {
                                         OutData[out].pof->setf(std::ios::scientific);
                                 }
                         }
                 }
 
                 return true;
         }
 
         return false;
 }

Here is the call graph for this function:

bool OutputHandler::Open	(	const int	out,
		const std::string &	postfix
	)

Definition at line 350 of file output.cc.

References EXT_SEP, iCurrPrecision, IsOpen(), MBDYN_EXCEPT_ARGS, OutData, pof, psExt, FileName::sGet(), UseDefaultPrecision(), UseScientific(), and UseText().

 {
         if (UseText(out) && !IsOpen(out)) {
                 std::string sCurrFileName = sGet();
                 std::stringstream fname_ss;
 
                 unsigned uExtIdx = sCurrFileName.find_last_of(EXT_SEP);
 
                 if (uExtIdx != std::string::npos) {
                         fname_ss << sCurrFileName.substr(0, uExtIdx);
 
                 } else {
                         fname_ss << sCurrFileName;
                 }
                 
                 fname_ss << postfix << psExt[out] << std::ends;
 
                 const std::string fname = fname_ss.str();
 
                 // Opens the stream
                 OutData[out].pof->open(fname.c_str());
 
                 if (!(*OutData[out].pof)) {
                         silent_cerr("Unable to open file "
                                 "\"" << fname << "\"" << std::endl);
                         throw ErrFile(MBDYN_EXCEPT_ARGS);
                 }
 
                 // Sets the field format
                 if (UseDefaultPrecision(out)) {
                         OutData[out].pof->precision(iCurrPrecision);
                 }
 
                 // Sets the notation
                 if (UseScientific(out)) {
                         OutData[out].pof->setf(std::ios::scientific);
                 }
 
                 return true;
         }
 
         return false;
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Output ( void ) const

inline

Definition at line 390 of file output.h.

References ASSERT, IsOpen(), ofOutput, and OUTPUT.

Referenced by DataManager::GetOutFile().

 {
 #ifdef DEBUG_COUT
         return const_cast<std::ostream &>(cout);
 #else
         ASSERT(IsOpen(OUTPUT));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofOutput));
 #endif
 }

Here is the call graph for this function:

void OutputHandler::OutputHandler_int ( void )

private

Definition at line 121 of file output.cc.

References ABSTRACT, AERODYNAMIC, AEROMODALS, AIRPROPS, BEAMS, currentStep, DOFSTATS, DRIVECALLERS, EIGENANALYSIS, ELECTRIC, EXTERNALS, FORCES, GENELS, GRAVITY, HYDRAULIC, INERTIA, JOINTS, LOADABLE, LOG, MODAL, NETCDF, ofAbstract, ofAerodynamic, ofAeroModals, ofAirProps, ofBeams, ofDofStats, ofDriveCallers, ofEigenanalysis, ofElectric, ofExternals, ofForces, ofGenels, ofGravity, ofHydraulic, ofInertia, ofJoints, ofLoadable, ofLog, ofModal, ofOutput, ofParameters, ofPartition, ofPlates, ofPresNodes, ofReferenceFrames, ofRestart, ofRestartXSol, ofRotors, ofStrNodes, ofThermalElements, ofThermalNodes, ofTraces, OutData, OUTPUT, OUTPUT_MAY_USE_NETCDF, OUTPUT_MAY_USE_TEXT, OUTPUT_USE_DEFAULT_PRECISION, OUTPUT_USE_SCIENTIFIC, OUTPUT_USE_TEXT, PARAMETERS, PARTITION, PLATES, PRESNODES, REFERENCEFRAMES, RESTART, RESTARTXSOL, ROTORS, STRNODES, THERMALELEMENTS, THERMALNODES, and TRACES.

Referenced by OutputHandler().

 {
         OutData[OUTPUT].flags = OUTPUT_USE_DEFAULT_PRECISION
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[OUTPUT].pof = &ofOutput;
 
         OutData[STRNODES].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT
                 | OUTPUT_MAY_USE_NETCDF;
         OutData[STRNODES].pof = &ofStrNodes;
 
         OutData[ELECTRIC].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[ELECTRIC].pof= &ofElectric;
 
         OutData[THERMALNODES].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[THERMALNODES].pof= &ofThermalNodes;
 
         OutData[THERMALELEMENTS].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[THERMALELEMENTS].pof= &ofThermalElements;
 
         OutData[ABSTRACT].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[ABSTRACT].pof = &ofAbstract;
 
         OutData[INERTIA].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT
                 | OUTPUT_MAY_USE_NETCDF;
         OutData[INERTIA].pof = &ofInertia;
 
         OutData[JOINTS].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT
                 | OUTPUT_MAY_USE_NETCDF;
         OutData[JOINTS].pof = &ofJoints;
 
         OutData[FORCES].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT
                 | OUTPUT_MAY_USE_NETCDF;
         OutData[FORCES].pof = &ofForces;
 
         OutData[BEAMS].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT
                 | OUTPUT_MAY_USE_NETCDF;
         OutData[BEAMS].pof = &ofBeams;
 
         OutData[ROTORS].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[ROTORS].pof = &ofRotors;
 
         OutData[RESTART].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[RESTART].pof = &ofRestart;
 
         OutData[RESTARTXSOL].flags = 0
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[RESTARTXSOL].pof = &ofRestartXSol;
 
         OutData[AERODYNAMIC].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT
                 | OUTPUT_MAY_USE_NETCDF;
         OutData[AERODYNAMIC].pof = &ofAerodynamic;
 
         OutData[HYDRAULIC].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[HYDRAULIC].pof = &ofHydraulic;
 
         OutData[PRESNODES].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[PRESNODES].pof = &ofPresNodes;
 
         OutData[LOADABLE].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT
                 | OUTPUT_MAY_USE_NETCDF;
         OutData[LOADABLE].pof = &ofLoadable;
 
         OutData[GENELS].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[GENELS].pof = &ofGenels;
 
         OutData[PARTITION].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[PARTITION].pof = &ofPartition;
 
         OutData[AEROMODALS].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[AEROMODALS].pof = &ofAeroModals;
 
         OutData[REFERENCEFRAMES].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[REFERENCEFRAMES].pof = &ofReferenceFrames;
 
         OutData[LOG].flags = 0
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[LOG].pof = &ofLog;
 
         OutData[AIRPROPS].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[AIRPROPS].pof = &ofAirProps;
 
         OutData[PARAMETERS].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[PARAMETERS].pof = &ofParameters;
 
         OutData[EXTERNALS].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[EXTERNALS].pof = &ofExternals;
 
         OutData[MODAL].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[MODAL].pof = &ofModal;
 
         OutData[PLATES].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT
                 | OUTPUT_MAY_USE_NETCDF;
         OutData[PLATES].pof = &ofPlates;
 
         OutData[GRAVITY].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                 | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[GRAVITY].pof = &ofGravity;
 
         OutData[DOFSTATS].flags = OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[DOFSTATS].pof = &ofDofStats;
 
         OutData[DRIVECALLERS].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                         | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[DRIVECALLERS].pof = &ofDriveCallers;
 
         OutData[TRACES].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                         | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[TRACES].pof = &ofTraces;
 
         OutData[EIGENANALYSIS].flags = OUTPUT_USE_DEFAULT_PRECISION | OUTPUT_USE_SCIENTIFIC
                         | OUTPUT_MAY_USE_TEXT | OUTPUT_USE_TEXT;
         OutData[EIGENANALYSIS].pof = &ofEigenanalysis;
 
         OutData[NETCDF].flags = 0
                 | OUTPUT_MAY_USE_NETCDF;
         OutData[NETCDF].pof = 0;
 
         currentStep = 0;
 }

bool OutputHandler::OutputOpen ( void )

Definition at line 557 of file output.cc.

References Open(), and OUTPUT.

Referenced by Init().

 {
         return Open(OUTPUT);
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Parameters ( void ) const

inline

Definition at line 559 of file output.h.

References ASSERT, IsOpen(), ofParameters, and PARAMETERS.

Referenced by ParameterNode::Output().

 {
         ASSERT(IsOpen(PARAMETERS));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofParameters));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Partition ( void ) const

inline

Definition at line 520 of file output.h.

References ASSERT, IsOpen(), ofPartition, and PARTITION.

 {
         ASSERT(IsOpen(PARTITION));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofPartition));
 }

Here is the call graph for this function:

bool OutputHandler::PartitionOpen ( void )

Definition at line 630 of file output.cc.

References ASSERT, IsOpen(), Open(), and PARTITION.

 {
         ASSERT(!IsOpen(PARTITION));
         return Open(PARTITION);
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Plates ( void ) const

inline

Definition at line 580 of file output.h.

References ASSERT, IsOpen(), ofPlates, and PLATES.

Referenced by Membrane4EAS::Output(), Shell4EAS::Output(), and Shell4EASANS::Output().

 {
         ASSERT(IsOpen(PLATES));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofPlates));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::PresNodes ( void ) const

inline

Definition at line 499 of file output.h.

References ASSERT, IsOpen(), ofPresNodes, and PRESNODES.

Referenced by PressureNode::Output().

 {
         ASSERT(IsOpen(PRESNODES));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofPresNodes));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::ReferenceFrames ( void ) const

inline

Definition at line 534 of file output.h.

References ASSERT, IsOpen(), ofReferenceFrames, and REFERENCEFRAMES.

Referenced by DataManager::DataManager().

 {
         ASSERT(IsOpen(REFERENCEFRAMES));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofReferenceFrames));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Restart ( void ) const

inline

Definition at line 471 of file output.h.

References ASSERT, IsOpen(), ofRestart, and RESTART.

Referenced by DataManager::MakeRestart().

 {
         ASSERT(IsOpen(RESTART));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofRestart));
 }

Here is the call graph for this function:

bool OutputHandler::RestartOpen ( bool openResXSol = false )

Definition at line 563 of file output.cc.

References FileName::_sPutExt(), ASSERT, iCurrPrecision, IsOpen(), MBDYN_EXCEPT_ARGS, nCurrRestartFile, OutData, pof, RESTART, RESTARTXSOL, SAFEDELETEARR, SAFENEWARR, STRLENOF, UseDefaultPrecision(), and UseScientific().

Referenced by DataManager::MakeRestart().

 {
         if (!IsOpen(RESTART)) {
                 char *resExt = NULL;
                 int n = nCurrRestartFile > 0 ?
                         (int)log10(nCurrRestartFile) + 1 : 1;
                 int lenExt = STRLENOF(".")
                         + n
                         + STRLENOF(".rst")
                         + 1;
 
                 SAFENEWARR(resExt, char, lenExt);
                 snprintf(resExt, lenExt, ".%.*d.rst", n, nCurrRestartFile);
                 /* Apre lo stream */
                 OutData[RESTART].pof->open(_sPutExt(resExt));
 
                 if(!(*OutData[RESTART].pof)) {
                         std::cerr << "Unable to open file '" << _sPutExt(resExt)
                                 << '\'' << std::endl;
                         throw ErrFile(MBDYN_EXCEPT_ARGS);
                 }
                 SAFEDELETEARR(resExt);
 
                 /* Setta la formattazione dei campi */
                 if(UseDefaultPrecision(RESTART)) {
                         OutData[RESTART].pof->precision(iCurrPrecision);
                 }
 
                 /* Setta la notazione */
                 if(UseScientific(RESTART)) {
                         OutData[RESTART].pof->setf(std::ios::scientific);
                 }
 
                 if (openResXSol) {
                         ASSERT(!IsOpen(RESTARTXSOL));
 
                         char *resXSolExt = NULL;
                         int n = nCurrRestartFile > 0 ?
                                 (int)log10(nCurrRestartFile) + 1 : 1;
                         int lenXSolExt = STRLENOF(".")
                                 + n
                                 + STRLENOF(".rst.X")
                                 + 1;
 
                         SAFENEWARR(resXSolExt, char, lenXSolExt);
                         snprintf(resXSolExt, lenXSolExt, ".%.*d.rst.X", n, nCurrRestartFile);
                         /* Apre lo stream */
                         OutData[RESTARTXSOL].pof->open(_sPutExt(resXSolExt));
                         if(!(*OutData[RESTARTXSOL].pof)) {
                                 std::cerr << "Unable to open file '" << _sPutExt(resExt)
                                         << '\'' << std::endl;
                                 throw ErrFile(MBDYN_EXCEPT_ARGS);
                         }
                         SAFEDELETEARR(resXSolExt);
                         /* non occorre settare la precisione e il formato
                         perche' il file e' binario */
                 }
 
                 nCurrRestartFile++;
 
                 return false;
         }
 
         return true;
 }

Here is the call graph for this function:

std::ostream & OutputHandler::RestartXSol ( void ) const

inline

Definition at line 478 of file output.h.

References ASSERT, IsOpen(), ofRestartXSol, and RESTART.

Referenced by DataManager::MakeRestart().

 {
         ASSERT(IsOpen(RESTART));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofRestartXSol));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Rotors ( void ) const

inline

Definition at line 464 of file output.h.

References ASSERT, IsOpen(), ofRotors, and ROTORS.

Referenced by Rotor::Output(), DynamicInflowRotor::Output(), and PetersHeRotor::Output().

 {
         ASSERT(IsOpen(ROTORS));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofRotors));
 }

Here is the call graph for this function:

void OutputHandler::SetCurrentStep ( long Step )

inline

Definition at line 110 of file output.h.

References currentStep.

                                               {
                 currentStep = Step;
         };

void OutputHandler::SetExceptions ( std::ios::iostate flags )

Definition at line 678 of file output.cc.

References LASTFILE, OutData, and pof.

Referenced by DataManager::DataManager().

 {
         for (int iCnt = 0; iCnt < LASTFILE; iCnt++) {
                 if(OutData[iCnt].pof) {
                         OutData[iCnt].pof->exceptions(flags);
                 }
         }
 }

void OutputHandler::SetNetCDF ( const OutputHandler::OutFiles out )

Definition at line 500 of file output.cc.

References flags, MBDYN_EXCEPT_ARGS, OutData, OUTPUT_MAY_USE_NETCDF, and OUTPUT_USE_NETCDF.

Referenced by DataManager::ReadControl().

 {
         if (!(OutData[out].flags & OUTPUT_MAY_USE_NETCDF)) {
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         OutData[out].flags |= OUTPUT_USE_NETCDF;
 }

void OutputHandler::SetPrecision ( int iNewPrecision )

Definition at line 663 of file output.cc.

References ASSERT, iCurrPrecision, iCurrWidth, IsOpen(), iWidth, LASTFILE, OutData, and UseDefaultPrecision().

Referenced by DataManager::ReadControl().

 {
         ASSERT(iNewPrecision > 0);
         if (iNewPrecision > 0) {
                 iCurrPrecision = iNewPrecision;
                 iCurrWidth = iNewPrecision + iWidth;
                 for (int iCnt = 0; iCnt < LASTFILE; iCnt++) {
                         if (UseDefaultPrecision(iCnt) && IsOpen(iCnt)) {
                                 OutData[iCnt].pof->width(iCurrWidth);
                                 OutData[iCnt].pof->precision(iCurrPrecision);
                         }
                 }
         }
 }

Here is the call graph for this function:

void OutputHandler::SetText ( const OutputHandler::OutFiles out )

Definition at line 455 of file output.cc.

References flags, MBDYN_EXCEPT_ARGS, OutData, OUTPUT_MAY_USE_TEXT, and OUTPUT_USE_TEXT.

 {
         if (!(OutData[out].flags & OUTPUT_MAY_USE_TEXT)) {
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         OutData[out].flags |= OUTPUT_USE_TEXT;
 }

void OutputHandler::SetWidth ( int iNewWidth )

Definition at line 647 of file output.cc.

References ASSERT, iCurrPrecision, iCurrWidth, IsOpen(), iWidth, LASTFILE, OutData, and UseDefaultPrecision().

 {
         ASSERT(iNewWidth > iWidth);
         if (iNewWidth > iWidth) {
                 iCurrWidth = iNewWidth;
                 iCurrPrecision = iCurrWidth-iWidth;
                 for (int iCnt = 0; iCnt < LASTFILE; iCnt++) {
                         if (UseDefaultPrecision(iCnt) && IsOpen(iCnt)) {
                                 OutData[iCnt].pof->width(iCurrWidth);
                                 OutData[iCnt].pof->precision(iCurrPrecision);
                         }
                 }
         }
 }

Here is the call graph for this function:

std::ostream & OutputHandler::StrNodes ( void ) const

inline

Definition at line 401 of file output.h.

References ASSERT, IsOpen(), ofStrNodes, and STRNODES.

Referenced by StructDispNode::Output(), and StructNode::Output().

 {
         ASSERT(IsOpen(STRNODES));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofStrNodes));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::ThermalElements ( void ) const

inline

Definition at line 422 of file output.h.

References ASSERT, IsOpen(), ofThermalElements, and THERMALELEMENTS.

 {
         ASSERT(IsOpen(THERMALELEMENTS));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofThermalElements));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::ThermalNodes ( void ) const

inline

Definition at line 415 of file output.h.

References ASSERT, IsOpen(), ofThermalNodes, and THERMALNODES.

 {
         ASSERT(IsOpen(THERMALNODES));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofThermalNodes));
 }

Here is the call graph for this function:

std::ostream & OutputHandler::Traces ( void ) const

inline

Definition at line 608 of file output.h.

References ASSERT, IsOpen(), ofTraces, and TRACES.

Referenced by DriveCaller::Trace().

 {
         ASSERT(IsOpen(TRACES));
         return const_cast<std::ostream &>(dynamic_cast<const std::ostream &>(ofTraces));
 }

Here is the call graph for this function:

bool OutputHandler::UseDefaultPrecision ( int out ) const

private

Definition at line 431 of file output.cc.

References ASSERT, LASTFILE, and UNKNOWN.

Referenced by Open(), RestartOpen(), SetPrecision(), and SetWidth().

 {
         ASSERT(out > OutputHandler::UNKNOWN);
         ASSERT(out < OutputHandler::LASTFILE);
 
         return UseDefaultPrecision(OutputHandler::OutFiles(out));
 }

bool OutputHandler::UseDefaultPrecision ( const OutputHandler::OutFiles out ) const

Definition at line 440 of file output.cc.

References flags, OutData, and OUTPUT_USE_DEFAULT_PRECISION.

 {
         return (OutData[out].flags & OUTPUT_USE_DEFAULT_PRECISION);
 }

bool OutputHandler::UseNetCDF ( int out ) const

private

Definition at line 491 of file output.cc.

References ASSERT, LASTFILE, and UNKNOWN.

 {
         ASSERT(out > OutputHandler::UNKNOWN);
         ASSERT(out < OutputHandler::LASTFILE);
 
         return UseNetCDF(OutputHandler::OutFiles(out));
 }

bool OutputHandler::UseNetCDF ( const OutputHandler::OutFiles out ) const

Definition at line 530 of file output.cc.

References flags, OutData, and OUTPUT_USE_NETCDF.

 {
         return (OutData[out].flags & OUTPUT_USE_NETCDF);
 }

bool OutputHandler::UseScientific ( int out ) const

private

Definition at line 416 of file output.cc.

References ASSERT, LASTFILE, and UNKNOWN.

Referenced by Open(), and RestartOpen().

 {
         ASSERT(out > OutputHandler::UNKNOWN);
         ASSERT(out < OutputHandler::LASTFILE);
 
         return UseScientific(OutputHandler::OutFiles(out));
 }

bool OutputHandler::UseScientific ( const OutputHandler::OutFiles out ) const

Definition at line 425 of file output.cc.

References flags, OutData, and OUTPUT_USE_SCIENTIFIC.

 {
         return (OutData[out].flags & OUTPUT_USE_SCIENTIFIC);
 }

bool OutputHandler::UseText ( int out ) const

private

Definition at line 446 of file output.cc.

References ASSERT, LASTFILE, and UNKNOWN.

Referenced by Open(), HydrodynamicPlainBearing::Output(), InlineFriction::Output(), AbsoluteDispForce::Output(), asynchronous_machine::Output(), InLineJoint::Output(), PrismaticJoint::Output(), SphericalHingeJoint::Output(), DeformableDispJoint::Output(), ModalMappingExt::Output(), DeformableHingeJoint::Output(), DeformableJoint::Output(), StructExtForce::Output(), Inertia::Output(), StructMappingExtForce::Output(), AbsoluteInternalDispForce::Output(), AutomaticStructDispElem::Output(), PlaneHingeJoint::Output(), UniformGravity::Output(), AbstractForce::Output(), ModalExt::Output(), CentralGravity::Output(), UniversalRotationJoint::Output(), TotalJoint::Output(), AbstractInternalForce::Output(), StructDispNode::Output(), AbsoluteForce::Output(), Beam2::Output(), AutomaticStructElem::Output(), Membrane4EAS::Output(), PlaneRotationJoint::Output(), AerodynamicBody::Output(), Wheel4::Output(), FollowerForce::Output(), Beam::Output(), Shell4EAS::Output(), AbsoluteCouple::Output(), Shell4EASANS::Output(), AerodynamicBeam::Output(), TotalPinJoint::Output(), FollowerCouple::Output(), AxialRotationJoint::Output(), DriveCaller::Output(), AerodynamicBeam2::Output(), AbsoluteInternalForce::Output(), FollowerInternalForce::Output(), AbsoluteInternalCouple::Output(), FollowerInternalCouple::Output(), StructNode::Output(), DataManager::OutputEigenvectors(), DataManager::OutputEigFullMatrices(), DataManager::OutputEigGeometry(), DataManager::OutputEigNaiveMatrices(), DataManager::OutputEigParams(), DataManager::OutputEigSparseMatrices(), and DriveCaller::Trace().

 {
         ASSERT(out > OutputHandler::UNKNOWN);
         ASSERT(out < OutputHandler::LASTFILE);
 
         return UseText(OutputHandler::OutFiles(out));
 }

bool OutputHandler::UseText ( const OutputHandler::OutFiles out ) const

Definition at line 485 of file output.cc.

References flags, OutData, and OUTPUT_USE_TEXT.

 {
         return (OutData[out].flags & OUTPUT_USE_TEXT);
 }

Member Data Documentation

long OutputHandler::currentStep

private

Definition at line 107 of file output.h.

Referenced by GetCurrentStep(), IncCurrentStep(), OutputHandler_int(), and SetCurrentStep().

unsigned OutputHandler::flags

Definition at line 139 of file output.h.

Referenced by ClearNetCDF(), ClearText(), SetNetCDF(), SetText(), UseDefaultPrecision(), UseNetCDF(), UseScientific(), and UseText().

int OutputHandler::iCurrPrecision

private

Definition at line 185 of file output.h.

Referenced by iP(), Open(), RestartOpen(), SetPrecision(), and SetWidth().

int OutputHandler::iCurrWidth

private

Definition at line 184 of file output.h.

Referenced by iW(), SetPrecision(), and SetWidth().

int OutputHandler::nCurrRestartFile

private

Definition at line 186 of file output.h.

Referenced by RestartOpen().

std::ofstream OutputHandler::ofAbstract

private

Definition at line 154 of file output.h.

Referenced by Abstract(), and OutputHandler_int().

std::ofstream OutputHandler::ofAerodynamic

private

Definition at line 162 of file output.h.

Referenced by Aerodynamic(), and OutputHandler_int().

std::ofstream OutputHandler::ofAeroModals

private

Definition at line 168 of file output.h.

Referenced by AeroModals(), and OutputHandler_int().

std::ofstream OutputHandler::ofAirProps

private

Definition at line 171 of file output.h.

Referenced by AirProps(), and OutputHandler_int().

std::ofstream OutputHandler::ofBeams

private

Definition at line 158 of file output.h.

Referenced by Beams(), and OutputHandler_int().

std::ofstream OutputHandler::ofDofStats

private

Definition at line 179 of file output.h.

Referenced by DofStats(), and OutputHandler_int().

std::ofstream OutputHandler::ofDriveCallers

private

Definition at line 180 of file output.h.

Referenced by DriveCallers(), and OutputHandler_int().

std::ofstream OutputHandler::ofEigenanalysis

private

Definition at line 182 of file output.h.

Referenced by Eigenanalysis(), and OutputHandler_int().

std::ofstream OutputHandler::ofElectric

private

Definition at line 153 of file output.h.

Referenced by Electric(), and OutputHandler_int().

std::ofstream OutputHandler::ofExternals

private

Definition at line 173 of file output.h.

Referenced by Externals(), and OutputHandler_int().

std::ofstream OutputHandler::ofForces

private

Definition at line 157 of file output.h.

Referenced by Forces(), and OutputHandler_int().

std::ofstream OutputHandler::ofGenels

private

Definition at line 166 of file output.h.

Referenced by Genels(), and OutputHandler_int().

std::ofstream OutputHandler::ofGravity

private

Definition at line 178 of file output.h.

Referenced by Gravity(), and OutputHandler_int().

std::ofstream OutputHandler::ofHydraulic

private

Definition at line 163 of file output.h.

Referenced by Hydraulic(), and OutputHandler_int().

std::ofstream OutputHandler::ofInertia

private

Definition at line 155 of file output.h.

Referenced by Inertia(), and OutputHandler_int().

std::ofstream OutputHandler::ofJoints

private

Definition at line 156 of file output.h.

Referenced by Joints(), and OutputHandler_int().

std::ofstream OutputHandler::ofLoadable

private

Definition at line 165 of file output.h.

Referenced by Loadable(), and OutputHandler_int().

std::ofstream OutputHandler::ofLog

private

Definition at line 170 of file output.h.

Referenced by Log(), and OutputHandler_int().

std::ofstream OutputHandler::ofModal

private

Definition at line 174 of file output.h.

Referenced by Modal(), and OutputHandler_int().

std::ofstream OutputHandler::ofOutput

private

Definition at line 151 of file output.h.

Referenced by Output(), and OutputHandler_int().

std::ofstream OutputHandler::ofParameters

private

Definition at line 172 of file output.h.

Referenced by OutputHandler_int(), and Parameters().

std::ofstream OutputHandler::ofPartition

private

Definition at line 167 of file output.h.

Referenced by OutputHandler_int(), and Partition().

std::ofstream OutputHandler::ofPlates

private

Definition at line 177 of file output.h.

Referenced by OutputHandler_int(), and Plates().

std::ofstream OutputHandler::ofPresNodes

private

Definition at line 164 of file output.h.

Referenced by OutputHandler_int(), and PresNodes().

std::ofstream OutputHandler::ofReferenceFrames

private

Definition at line 169 of file output.h.

Referenced by OutputHandler_int(), and ReferenceFrames().

std::ofstream OutputHandler::ofRestart

private

Definition at line 160 of file output.h.

Referenced by OutputHandler_int(), and Restart().

std::ofstream OutputHandler::ofRestartXSol

private

Definition at line 161 of file output.h.

Referenced by OutputHandler_int(), and RestartXSol().

std::ofstream OutputHandler::ofRotors

private

Definition at line 159 of file output.h.

Referenced by OutputHandler_int(), and Rotors().

std::ofstream OutputHandler::ofStrNodes

private

Definition at line 152 of file output.h.

Referenced by OutputHandler_int(), and StrNodes().

std::ofstream OutputHandler::ofThermalElements

private

Definition at line 176 of file output.h.

Referenced by OutputHandler_int(), and ThermalElements().

std::ofstream OutputHandler::ofThermalNodes

private

Definition at line 175 of file output.h.

Referenced by OutputHandler_int(), and ThermalNodes().

std::ofstream OutputHandler::ofTraces

private

Definition at line 181 of file output.h.

Referenced by OutputHandler_int(), and Traces().

struct { ... } OutputHandler::OutData[LASTFILE]

Referenced by ClearNetCDF(), ClearText(), Close(), Get(), IsOpen(), Open(), OutputHandler_int(), RestartOpen(), SetExceptions(), SetNetCDF(), SetPrecision(), SetText(), SetWidth(), UseDefaultPrecision(), UseNetCDF(), UseScientific(), UseText(), and ~OutputHandler().

std::ofstream* OutputHandler::pof

Definition at line 138 of file output.h.

Referenced by Open(), RestartOpen(), and SetExceptions().

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation