C++ debugStream函数代码示例

// ===================================================
// Conversion Methods
// ===================================================
void
OneDFSIPhysicsLinear::fromUToW ( Real& W1, Real& W2, const Real& U1, const Real& U2, const UInt& iNode ) const
{
    W1 = U2 + celerity0 ( iNode ) * ( U1 - M_dataPtr->area0 ( iNode ) );

    W2 = U2 - celerity0 ( iNode ) * ( U1 - M_dataPtr->area0 ( iNode ) );

#ifdef HAVE_LIFEV_DEBUG
    debugStream ( 6320 ) << "[OneDFSIModel_Physics_Linear::fromUToW] Q " << U2 << "\n";
    debugStream ( 6320 ) << "[OneDFSIModel_Physics_Linear::fromUToW] W1 " << W1 << "\n";
    debugStream ( 6320 ) << "[OneDFSIModel_Physics_Linear::fromUToW] W2 " << W2 << "\n";
    debugStream ( 6320 ) << "[OneDFSIModel_Physics_Linear::fromUToW] celerity " << celerity0 ( iNode ) << "\n";
    debugStream ( 6320 ) << "[OneDFSIModel_Physics_Linear::fromUToW] ( _U1 - area0( iNode ) ) " << ( U1 - M_dataPtr->area0 ( iNode ) ) << "\n";
#endif
}

void
FSISolver::iterate()
{
    debugStream( 6220 ) << "============================================================\n";
    debugStream( 6220 ) << "Solving FSI at time " << M_data->dataFluid()->dataTime()->time() << " with FSI: " << M_data->method()  << "\n";
    debugStream( 6220 ) << "============================================================\n";

    // Update the system
    M_oper->updateSystem( );

    // We extract a copy to the solution (\todo{uselessly})
    vectorPtr_Type lambda(new vector_Type(M_oper->solution()));
    //M_oper->solutionPtr(lambda);//copy of a shared_ptr

    // the newton solver
    UInt maxiter = M_data->maxSubIterationNumber();
    UInt status = NonLinearRichardson( *lambda,
                                       *M_oper,
                                       M_data->absoluteTolerance(),
                                       M_data->relativeTolerance(),
                                       maxiter,
                                       M_data->errorTolerance(),
                                       M_data->NonLinearLineSearch(),
                                       M_out_res,
                                       M_data->dataFluid()->dataTime()->time() );

    // We update the solution
    M_oper->updateSolution( *lambda );

    if (status == EXIT_FAILURE)
    {
        std::ostringstream __ex;
        __ex << "FSISolver::iterate ( " << M_data->dataFluid()->dataTime()->time() << " ) Inners iterations failed to converge\n";
        throw std::logic_error( __ex.str() );
    }
    else
    {
        //M_oper->displayer().leaderPrint("FSI-  Number of inner iterations:              ", maxiter, "\n" );
        if (M_epetraWorldComm->MyPID() == 0)
        {
            M_out_iter << M_data->dataFluid()->dataTime()->time() << " " << maxiter;
        }
    }

    debugStream( 6220 ) << "FSISolver iteration at time " << M_data->dataFluid()->dataTime()->time() << " done\n";
    debugStream( 6220 ) << "============================================================\n";
    std::cout << std::flush;
}

void
MultiscaleModelFSI1D::buildModel()
{

#ifdef HAVE_LIFEV_DEBUG
    debugStream ( 8130 ) << "MultiscaleModelFSI1D::buildModel() \n";
#endif

    // Display data
    //    if ( M_comm->MyPID() == 0 )
    //        M_data->showMe();

    M_solver->buildConstantMatrices();

    // Update previous solution
    copySolution ( *M_solution, *M_solution_tn );

#ifdef JACOBIAN_WITH_FINITEDIFFERENCE
    if ( M_couplings.size() > 0 )
    {
        updateLinearModel();
    }
#endif

}

FSIOperator::fluidBchandlerPtr_Type BCh_monolithicFluid (FSIOperator& _oper, bool const& isOpen = true)
{
    // Boundary conditions for the fluid velocity
    debugStream ( 10000 ) << "Boundary condition for the fluid\n";

    if (! _oper.isFluid() )
    {
        return FSIOperator::fluidBchandlerPtr_Type();
    }

    FSIOperator::fluidBchandlerPtr_Type BCh_fluid ( new FSIOperator::fluidBchandler_Type );

    BCFunctionBase bcf      (fZero);
    BCFunctionBase in_flow  (/*uInterpolated*/u2normal/*aortaPhisPress*/);
    //    BCFunctionBase out_flow (fZero);
    //BCFunctionBase in_flow  (LumpedHeart::outPressure);

    BCFunctionBase out_press (FlowConditions::outPressure0);
    BCFunctionBase bcfw0 (w0);

    // if(!isOpen)
    //   BCh_fluid->addBC("InFlow" , INLET,  Natural, Full, bcf,3);


    BCh_fluid->addBC ("OutFlow", OUTLET,  Natural,  Normal, out_press);
    //BCh_fluid->addBC("OutFlow", INOUTEDGE,  EssentialEdges,  Full, bcf,3);

    return BCh_fluid;
}

// ===================================================
// Methods
// ===================================================
const Real&
Parser::evaluate ( const ID& id )
{
    if ( M_evaluate )
    {
        M_results.clear();
        stringIterator_Type start, end;

        for ( UInt i (0); i < M_strings.size(); ++i )
        {
            start = M_strings[i].begin();
            end   = M_strings[i].end();
#ifdef HAVE_BOOST_SPIRIT_QI
#ifdef ENABLE_SPIRIT_PARSER
            qi::phrase_parse ( start, end, M_calculator, ascii::space, M_results );
#else
            std::cerr << "!!! ERROR: The Boost Spirit parser has been disabled !!!" << std::endl;
            std::exit ( EXIT_FAILURE );
#endif /* ENABLE_SPIRIT_PARSER */
#else
            std::cerr << "!!! ERROR: Boost version < 1.41 !!!" << std::endl;
            std::exit ( EXIT_FAILURE );
#endif
        }
        M_evaluate = false;
    }

#ifdef HAVE_LIFEV_DEBUG
    debugStream ( 5030 ) << "Parser::evaluate          results[ " << id << "]: " << M_results[id] << "\n";
#endif

    return M_results[id];
}

void
MultiscaleModelMultiscale::updateModel()
{

#ifdef HAVE_LIFEV_DEBUG
    debugStream ( 8110 ) << "MultiscaleModelMultiscale::updateModel() \n";
#endif

    for ( multiscaleModelsContainerConstIterator_Type i = M_modelsList.begin(); i != M_modelsList.end(); ++i )
    {
        ( *i )->updateModel();
    }

    for ( multiscaleCouplingsContainerConstIterator_Type i = M_couplingsList.begin(); i != M_couplingsList.end(); ++i )
    {
        ( *i )->updateCoupling();

        if ( M_algorithm->type() != Explicit )
        {
            ( *i )->extrapolateCouplingVariables();
        }
        else
        {
            ( *i )->initializeCouplingVariables();
        }
    }
}

FSIOperator::fluidBchandlerPtr_Type BCh_monolithicFluid (FSIOperator& _oper, bool const& /*isOpen=true*/)
{
    // Boundary conditions for the fluid velocity
    debugStream ( 10000 ) << "Boundary condition for the fluid\n";

    if (! _oper.isFluid() )
    {
        return FSIOperator::fluidBchandlerPtr_Type();
    }

    FSIOperator::fluidBchandlerPtr_Type BCh_fluid ( new FSIOperator::fluidBchandler_Type );

    BCFunctionBase bcf      (fZero);
    BCFunctionBase in_flow  (uInterpolated);
    //    BCFunctionBase out_flow (fZero);

    BCFunctionBase out_press3 (FlowConditions::outPressure0);

    BCFunctionBase InletVect (aneurismFluxInVectorial);
    //BCFunctionBase bcfw0 (w0);

    //Inlets
    BCh_fluid->addBC ("InFlow" , INLET,  EssentialVertices, Full, InletVect, 3);

    //Outlets

    //Absorbing BC seemed not to work
    //Absorbing BC on outlet 2and3 caused instabilities
    BCh_fluid->addBC ("out3", OUTLET, Natural,  Normal, out_press3);
    //BCh_fluid->addBC("out3", OUTLET, Natural,  Normal, bcf);

    return BCh_fluid;
}

    /**
     * Unregister a product
     *
     * @param id
     * @sa registerProduct
     * @return true if unregistration went fine, false otherwise
     */
    bool unregisterProduct( const identifier_Type& id )
    {
#ifdef HAVE_LIFEV_DEBUG
        debugStream( 2200 ) << "Unregistered type with id : " << id << "\n";
#endif
        return M_associations.erase( id ) == 1;
    }

FSIOperator::solidBchandlerPtr_Type BCh_solidInvLin (FSIOperator& _oper)
{

    if (! _oper.isSolid() )
    {
        return FSIOperator::solidBchandlerPtr_Type();
    }

    // Boundary conditions for the solid displacement
    debugStream ( 10000 ) << "Boundary condition for the inverse linear solid\n";
    FSIOperator::solidBchandlerPtr_Type BCh_solidLinInv ( new FSIOperator::solidBchandler_Type );

    BCFunctionBase bcf (fZero);

    BCh_solidLinInv->addBC ("Base",      2, Essential, Full, bcf,  3);
    BCh_solidLinInv->addBC ("EdgesIn",    20, EssentialVertices, Full, bcf,  3);

    //     if (_oper.method() == "steklovPoincare")
    //     {
    //         steklovPoincare *SPOper = dynamic_cast<steklovPoincare *>(&_oper);
    //         SPOper->setSolidInvLinInterfaceStress((LifeV::Vector&) _oper.residual());

    //         BCh_solidLinInv->addBC("Interface", 100, Natural, Full,
    //                                *SPOper->bcvSolidInvLinInterfaceStress(), 3);
    //     }
    //     else
    //     {
    //         exactJacobian  *EJOper = dynamic_cast<exactJacobian *>(&_oper);
    //         EJOper->setDerFluidLoadToStructure(_oper.fluid().residual());
    //         BCh_solidLinInv->addBC("Interface", 1, Natural,   Full,
    //                             *EJOper->bcvDerFluidLoadToStructure(), 3);
    //     }

    return BCh_solidLinInv;
}

    /**
     * Register a product.
     *
     * A product is composed of an identifier (typically a
     * std::string) and a functor that will create the associated
     * object.
     *
     * @param id identifier for the object to be registered
     * @param creator the functor that will create the registered
     * object
     *
     * @return true if registration went fine, false otherwise
     */
    bool registerProduct( const identifier_Type& id, creator_Type creator )
    {
#ifdef HAVE_LIFEV_DEBUG
        debugStream( 2200 ) << "Registered type with id : " << id << "\n";
#endif
        return M_associations.insert( typename productId_Type::value_type( id, creator ) ).second;
    }

FSIOperator::solidBchandlerPtr_Type BCh_monolithicSolid (FSIOperator& _oper)
{

    if (! _oper.isSolid() )
    {
        return FSIOperator::solidBchandlerPtr_Type();
    }

    // Boundary conditions for the solid displacement
    debugStream ( 10000 ) << "Boundary condition for the solid\n";
    FSIOperator::solidBchandlerPtr_Type BCh_solid ( new FSIOperator::solidBchandler_Type );

    BCFunctionBase bcf (fZero);

    BCh_solid->addBC ("Top",   RING, Essential, Full, bcf,  3);
    BCh_solid->addBC ("Base",  RING2, Essential, Full, bcf,  3);

    aortaVelIn::S_timestep = _oper.dataFluid()->dataTime()->timeStep();
    BCFunctionBase hyd (fZero);
    BCFunctionBase young (E);
    //robin condition on the outer wall
    _oper.setRobinOuterWall (hyd, young);
    BCh_solid->addBC ("OuterWall", OUTERWALL, Robin, Normal, _oper.bcfRobinOuterWall() );

    return BCh_solid;
}

float bbReadFloat(bbStream* s)
{
	if (debug)
		debugStream(s);
	float n = 0;
	s->read((char*)&n, 4);
	return n;
}

int bbReadInt(bbStream* s)
{
	if (debug)
		debugStream(s);
	int n = 0;
	s->read((char*)&n, 4);
	return n;
}

int bbReadByte(bbStream* s)
{
	if (debug)
		debugStream(s);
	int n = 0;
	s->read((char*)&n, 1);
	return n;
}

void bbCopyStream(bbStream* s, bbStream* d, int buff_size)
{
	if (debug) {
		debugStream(s);
		debugStream(d);
		if (buff_size < 1 || buff_size > 1024 * 1024)
			ThrowRuntimeException("Illegal buffer size");
	}
	char* buff = new char[buff_size];
	while (s->eof() == 0 && d->eof() == 0) {
		int n = s->read(buff, buff_size);
		d->write(buff, n);
		if (n < buff_size)
			break;
	}
	delete buff;
}