C++ TPZVec::Resize方法代码示例

void TPZEulerConsLawDEP::Flux(TPZVec<REAL> &x,TPZVec<REAL> &Sol,TPZFMatrix &DSol,
						   TPZFMatrix &axes,TPZVec<REAL> &flux) {
	TPZVec<REAL> Fx,Fy,Fz;
	Flux(Sol,Fx,Fy,Fz);
	int cap = Sol.NElements();
	int nstate = NStateVariables(),i;
	if(cap != nstate){
		PZError << "\nTPZEulerConsLawDEP::Flux data size error\n";
		flux.Resize(0);
		return;
	}
	if(nstate == 3){
		flux.Resize(3);
		for(i=0;i<3;i++) flux[i] = Fx[i];
		return;
	} else
		if(nstate == 4){
			flux.Resize(8);
			for(i=0;i<4;i++) flux[i] = Fx[i];
			for(i=4;i<8;i++) flux[i] = Fy[i];
			return;
		} else
			if(nstate == 5){
				flux.Resize(15);
				for(i=00;i<05;i++) flux[i] = Fx[i];
				for(i=05;i<10;i++) flux[i] = Fy[i];
				for(i=10;i<15;i++) flux[i] = Fz[i];
			}
}

void RSNAMeshPoints(TPZVec< TPZVec<REAL> > & pt, TPZVec< TPZVec< int64_t> > &elms)
{
   REAL x1 = 0.,
        x2 = 4.12791,
	y1 = 0.,
	y2 = 1.;

   pt.Resize(6);
   TPZVec<REAL> coord(3);

   coord[0] = x1;
   coord[1] = y1;
   coord[2] = 0.;
   pt[0] = coord;

   coord[0] = x2/2.;
   coord[1] = y1;
   coord[2] = 0.;
   pt[1] = coord;

   coord[0] = x2;
   coord[1] = y1;
   coord[2] = 0.;
   pt[2] = coord;

   coord[0] = x1;
   coord[1] = y2;
   coord[2] = 0.;
   pt[3] = coord;

   coord[0] = x2/2;
   coord[1] = y2;
   coord[2] = 0.;
   pt[4] = coord;

   coord[0] = x2;
   coord[1] = y2;
   coord[2] = 0.;
   pt[5] = coord;

// quadrilateral data

   TPZVec< int64_t > nodes(4);

   elms.Resize(2);

   nodes[0] = 0;
   nodes[1] = 1;
   nodes[2] = 4;
   nodes[3] = 3;
   elms[0] = nodes;

   nodes[0] = 1;
   nodes[1] = 2;
   nodes[2] = 5;
   nodes[3] = 4;
   elms[1] = nodes;

}

void TPZEuler::Solution(TPZVec<REAL> &Sol,TPZFMatrix<REAL> &DSol,TPZFMatrix<REAL> &axes,int var,
						TPZVec<REAL> &Solout){
	if(var == 1) {
		Solout.Resize(1);
		Solout[0] = gEul.Pressure(Sol);
	} else if(var ==2) {
		Solout.Resize(1);
		Solout[0] = Sol[0];
	} else if(var == 3) {
		Solout.Resize(2);
		Solout[0] = Sol[1];
		Solout[1] = Sol[2];
	} else TPZMaterial::Solution(Sol,DSol,axes,var,Solout);
}

void ReadSolution(ifstream &arq, TPZVec<REAL> &sol, TPZCompMesh *cmesh, int &nstate, TPZVec<int> &dimstate){

  int i,j,totaldim=0;
  for(i=0;i<nstate;i++) totaldim += dimstate[i];
  TPZVec<REAL> pt(3,0.);
  TPZVec<REAL> coord(3,0.);
  TPZVec<REAL> auxsol(totaldim,0.);

  int iter = 0;
  int nel = cmesh->NElements();
  int solsize = totaldim * nel;
  sol.Resize(solsize);
  sol.Fill(0.);

  for(i=0; i<nel; i++){
    TPZCompEl *el = cmesh->ElementVec()[i];
    if (!el) continue;
    el->Reference()->CenterPoint(el->Reference()->NSides()-1,pt);
    el->Reference()->X(pt,coord);
    EvaluateSolution(coord,auxsol);
    for (j=0;j<totaldim;j++){
      sol[iter] = auxsol[j];
      iter++;
    }
  }
}

void TPZArtDiff::PrepareFastDiff(int dim, TPZFMatrix<REAL> &jacinv, TPZVec<STATE> &sol,
								 TPZFMatrix<STATE> &dsol, TPZFMatrix<REAL> & dphi,
								 TPZVec<TPZVec<STATE> > & TauDiv, TPZVec<TPZDiffMatrix<STATE> > * pTaudDiv)
{
	TPZVec<TPZDiffMatrix<STATE> > Ai;
	TPZVec<TPZDiffMatrix<STATE> > Tau;
	
	TPZEulerConsLaw::JacobFlux(fGamma, dim, sol, Ai);
	ComputeTau(dim, jacinv, sol, Ai, Tau);
	
	TPZVec<STATE> Div;
	
	TPZDiffMatrix<STATE> * pdDiv = NULL;
	TPZDiffMatrix<STATE> dDiv;
	if(pTaudDiv) pdDiv = & dDiv;
	
	//Computing the divergent
	Divergent(dsol, dphi, Ai, Div, pdDiv);
	TauDiv.Resize(dim);
	if(pTaudDiv)pTaudDiv->Resize(dim);
	
	// computing Tau.Div = {Tx.Div, Ty.Div, Tz.Div}
	// and Tau.dDiv = {Tx.dDiv, Ty.dDiv, Tz.dDiv}, if requested
	int k;
	for(k=0;k<dim;k++)
	{
		Tau[k].Multiply(Div, TauDiv[k]);
		if(pTaudDiv)Tau[k].Multiply(dDiv, pTaudDiv->operator[](k));
		
	}
}

	void TPZPrism::CenterPoint(int side, TPZVec<REAL> &center) {
		center.Resize(Dimension);
		int i;
		for(i=0; i<Dimension; i++) {
			center[i] = MidSideNode[side][i];
		}
	}

void TPZIntelGen<TSHAPE>::GetInterpolationOrder(TPZVec<int> &ord) {
	ord.Resize(TSHAPE::NSides-TSHAPE::NCornerNodes);
	int i;
	for(i=0; i<TSHAPE::NSides-TSHAPE::NCornerNodes; i++) {
		ord[i] = SideOrder(i+TSHAPE::NCornerNodes);
	}
}

void TPZMetis::Subdivide(int nParts, TPZVec < int > & Domains)
{
	TPZManVector<int> Adjacency,AdjacencyIndex;
	TPZManVector<int> AdjacencyWeight;
	ConvertToElementoToElementGraph(fElementGraph,fElementGraphIndex,Adjacency,AdjacencyWeight,AdjacencyIndex);
	
#ifdef LOG4CXX
	{
		std::stringstream sout;
		TPZRenumbering::Print(Adjacency,AdjacencyIndex,"Element to element graph",sout);
		LOGPZ_DEBUG(logger,sout.str())
	}
#endif
	
#ifdef USING_METIS
	int nVertices = AdjacencyIndex.NElements() -1;

	Domains.Resize(nVertices);
	// Upon successful completion, nEdgesCutted stores the edge-cut or the total communication volume of the partitioning solution.
	int nEdgesCutted = 0;

	TPZVec<int> Options(METIS_NOPTIONS);
	METIS_SetDefaultOptions(&Options[0]);
	
    int ncon = 2;
	if(METIS_PartGraphRecursive(&nVertices, &ncon, &AdjacencyIndex[0], &Adjacency[0], NULL, NULL, NULL,   // &AdjacencyWeight[0],
					&nParts, NULL, NULL, &Options[0], &nEdgesCutted, &Domains[0]) != METIS_OK)
		DebugStop();
#else
    DebugStop();
#endif
	
}

// metodo para computar erros
void TPZMatPoissonD3::Solution(TPZMaterialData &data, int var, TPZVec<STATE> &Solout){
    
    Solout.Resize( this->NSolutionVariables(var));

    
    if(var == 1){ //function (state variable Q)
        for (int ip = 0; ip<fDim; ip++)
        {
            Solout[ip] = data.sol[0][ip];
        }
        
        return;
    }
    
    if(var == 2){ //function (state variable p)
        
        TPZVec<STATE> SolP;
        SolP = data.sol[0];
        
        Solout[0] = SolP[0];
        return;
    }
    
    
}

void TPZMaterial::Solution(TPZVec<REAL> &Sol,TPZFMatrix<REAL> &/*DSol*/,TPZFMatrix<REAL> &/*axes*/,int var,
						   TPZVec<REAL> &Solout){
	if(var == 0) Solout = Sol;
	else if(var == 99 || var == 100 || var == 101 || var == 102) {
		//  	PZError << "TPZMaterial var = "<< var << " the element should treat this case\n";
		Solout[0] = Sol[0]; // = 0.;
	} else Solout.Resize(0);
}

 void TPZPrism::ParametricDomainNodeCoord(int node, TPZVec<REAL> &nodeCoord)
 {
     if(node > NCornerNodes)
     {
         DebugStop();
     }
     nodeCoord.Resize(Dimension, 0.);
     switch (node) {
         case (0):
         {
             nodeCoord[0] =  0.;
             nodeCoord[1] =  0.;
             nodeCoord[2] = -1.;
             break;
         }
         case (1):
         {
             nodeCoord[0] =  1.;
             nodeCoord[1] =  0.;
             nodeCoord[2] = -1.;
             break;
         }
         case (2):
         {
             nodeCoord[0] =  0.;
             nodeCoord[1] =  1.;
             nodeCoord[2] = -1.;
             break;
         }
         case (3):
         {
             nodeCoord[0] = 0.;
             nodeCoord[1] = 0.;
             nodeCoord[2] = 1.;
             break;
         }
         case (4):
         {
             nodeCoord[0] = 1.;
             nodeCoord[1] = 0.;
             nodeCoord[2] = 1.;
             break;
         }
         case (5):
         {
             nodeCoord[0] = 0.;
             nodeCoord[1] = 1.;
             nodeCoord[2] = 1.;
             break;
         }
         default:
         {
             DebugStop();
             break;
         }
     }
 }

/// associate scale factors with the equations and state variables
void TPBrSteamFlux::InletScales(TPZVec<REAL> &eqscales, TPZVec<REAL> &statescales)
{
    eqscales.Resize(NumInletVars+NumFluxEq);
    statescales.Resize(NumInletVars+NumFluxEq);
    eqscales[EInletMassFlux] = 1.;
    eqscales[EInletEnergyFlux] = 1.;
    eqscales[EInletStateEqs] = 1.;
    statescales[EInletPressure] = TPBrScales::fReferencePressure;
    statescales[EInletSteamSaturation] = 1.;
    statescales[EInletTemperature] = 1.;
    TPZManVector<REAL> loceqscale,locstatescale;
    Scales(loceqscale, locstatescale);
    int ist;
    int nst = loceqscale.NElements();
    for (ist=0; ist<nst; ist++) {
        eqscales[NumInletVars+ist] = loceqscale[ist];
        statescales[NumInletVars+ist] = locstatescale[ist];
    }
}

/// associate scale factors with the equations and state variables
void TPBrSteamFlux::Scales(TPZVec<REAL> &eqscales, TPZVec<REAL> &statescales)
{
    eqscales.Resize(NumFluxEq);
    statescales.Resize(NumFluxEq);
    eqscales[EMassFluxWaterEq] = 1.;
    eqscales[EMassFluxSteamEq] = 1.;
    eqscales[EMassFluxOilEq] = 1.;
    eqscales[EDarcyVelocityWaterEq] = 1.;
    eqscales[EDarcyVelocitySteamEq] = 1.;
    eqscales[EDarcyVelocityOilEq] = 1.;
    eqscales[EEnergyFluxEq] = 1.;
    statescales[EMassFluxWater] = 1.;
    statescales[EMassFluxSteam] = 1.;
    statescales[EMassFluxOil] = 1.;
    statescales[EDarcyVelocityWater] = 1.;
    statescales[EDarcyVelocitySteam] = 1.;
    statescales[EDarcyVelocityOil] = 1.;
    statescales[EEnergyFlux] = 1.;
}

void TPZPrimalPoisson::Solution(TPZMaterialData &data, int var, TPZVec<STATE> &Solout){
    
    Solout.Resize( this->NSolutionVariables(var));
    TPZVec<STATE> p, q, f;
    
    if(var == 1){
        for (int i=0; i < this->Dimension(); i++)
        {
            Solout[i] = -data.dsol[0][i];
        }
        return;
    }
    
    if(var == 2){
            Solout[0] = data.sol[0][0];
        return;
    }
    
    if(var == 3){
        TPZManVector<STATE,1> f(1,0.0);
        TPZFNMatrix<4,STATE> df(4,1,0.0);
        if (this->HasForcingFunctionExact()) {
            this->fForcingFunctionExact->Execute(data.x, f, df);
        }
        
        for (int i=0; i < this->Dimension(); i++)
        {
            Solout[i] = df(i,0);
        }
        return;
    }
    
    if(var == 4){
        TPZManVector<STATE,1> f(1,0.0);
        TPZFNMatrix<4,STATE> df(4,1,0.0);
        if (this->HasForcingFunctionExact()) {
            this->fForcingFunctionExact->Execute(data.x, f, df);
        }
        Solout[0] = f[0];
        return;
    }
    
    if(var == 5){
        TPZManVector<STATE,1> f(1,0.0);
        TPZFNMatrix<4,STATE> df(4,1,0.0);
        if (this->HasForcingFunctionExact()) {
            this->fForcingFunctionExact->Execute(data.x, f, df);
        }
        Solout[0] = df(3,0);
        return;
    }
    
    DebugStop();
    
}

void TPZBiharmonic::Solution(TPZVec<REAL> &Sol,TPZFMatrix<REAL> &DSol,TPZFMatrix<REAL> &/*axes*/,
							 int var,TPZVec<REAL> &Solout){
	if(var == 0 || var == 1) Solout[0] = Sol[0];//function
	if(var == 2) {
		Solout.Resize(DSol.Rows());
		int id;
		for(id=0 ; id  < DSol.Rows(); id++) {
			Solout[id] = DSol(id,0);//derivate
		}
	}
}