Пример #1
0
void SGSSmoother( VT &sol, const MT &M, VT &def )
// backward Gauss-Seidel
// result in sol_vec; def_vec: correct defect before call, after call destroyed
{
	typename VT::Iterator viter(def); 
	typename VT::RevIterator vReviter(def); 
	typename VT::VectorEntry row, col; 
	typename MT::MatrixEntry me; 
	register double sum, diag;
	int row_index;

    /* symmetric Gauss-Seidel */

	while(viter(row))
	{
		typename MT::Iterator miter(M,row);
		
		row_index = row.GetIndex();
		sum = def[row];
		miter(me);
		diag = M[me];
		while(miter(me))
		{
			col = me.dest();
			if( col.GetIndex() < row_index )
				sum -= M[me] * def[col];
		}
		def[row] = sum / diag;
	}

	viter.reset();
	while(viter(row))
		def[row] *= M.DiagValue(row);
	
	while(vReviter(row))
	{
		typename MT::Iterator miter(M,row);
		
		row_index = row.GetIndex();
		sum = def[row];
		miter(me);
		diag = M[me];
		while(miter(me))
		{
			col = me.dest();
			if( col.GetIndex() > row_index )
				sum -= M[me] * def[col];
		}
		def[row] = sum / diag;
	}

	sol += def;	// update solution
	
	return;
}
Пример #2
0
void MarkStrongLinks(const MT &A, const FAMGGrid &grid)
{
	typedef typename MT::Vector VT;
	const typename MT::GridVector& gridvec = (typename MT::GridVector&)grid.GetGridVector();
	typename MT::MatrixEntry matij;
	typename VT::VectorEntry vi;
	typename VT::Iterator viter(gridvec);
    
     
	while (viter(vi))
	{
        typename MT::Iterator mij_iter(A,vi);
        mij_iter(matij);
        matij.set_strong(1);
        while( mij_iter(matij) )
        {
            // if(VSKIPME(matij.dest().myvector(),0)) matij.set_strong(0);
            // else matij.set_strong(1);
             matij.set_strong(1);
        }

    }
    
	return;
}
Пример #3
0
void Scale( VT& v, double scale )
{
	// typename is a new C++ keyword!
	typename VT::Iterator viter(v); 
	typename VT::VectorEntry ve; 
	
	while(viter(ve))
		v[ve] *= scale;	
}
Пример #4
0
void SubtractValue( VT &dest, const VT &source )
{
	// typename is a new C++ keyword!
	typename VT::Iterator viter(dest); 
	typename VT::VectorEntry ve; 
	
	while(viter(ve))
		dest[ve] -= source[ve];
}
Пример #5
0
void SetValue( VT &v, double val )
{
	// typename is a new C++ keyword!
	typename VT::Iterator viter(v); 
	typename VT::VectorEntry ve; 
	
	while(viter(ve))
		v[ve] = val;
}
Пример #6
0
void AddScaledValue( VT &dest, double scale, const VT &source )
{
	// typename is a new C++ keyword!
	typename VT::Iterator viter(dest); 
	typename VT::VectorEntry ve; 
	
	while(viter(ve))
		dest[ve] += scale * source[ve];
}
Пример #7
0
void JacobiSmoother( VT &sol, const MT &M, const VT &def )
// result in sol_vec; def_vec: correct defect before call, after call destroyed
{
	typename VT::Iterator viter(sol); 
	typename VT::VectorEntry ve; 

	while(viter(ve))
		sol[ve] += def[ve] / M.DiagValue(ve);

	return;
}
Пример #8
0
void JacobiSmoothFG( VT &sol, const MT &A, const VT &def )
// changes only the fine unknowns
// result in sol_vec; def_vec: correct defect before call, after call destroyed
{
	typename VT::Iterator viter(sol); 
	typename VT::VectorEntry ve; 
	const FAMGSparseVector *svsol  = sol.GetSparseVectorPtr();
	const FAMGSparseVector *svdef  = def.GetSparseVectorPtr();
	const FAMGSparseBlock *sb  = A.GetDiagSparseBlockPtr();
	double *solptr, *defptr, *matptr;

    short nr = sb->Get_nr();
    if(nr != sb->Get_nc()) assert(0);
    if(nr != svsol->Get_n()) assert(0);
    if(nr != svdef->Get_n()) assert(0);

    // todo: implement for more general vectors
    for(short i = 1; i < nr; i++)
    {
        if(svsol->Get_comp(i) - svsol->Get_comp(i-1) != 1) assert(0);
        if(svdef->Get_comp(i) - svdef->Get_comp(i-1) != 1) assert(0);
    }

    short sol_off = svsol->Get_comp(0);
    short def_off = svdef->Get_comp(0);

    double *decomp = new double[nr*nr]; 
    short *pivotmap = new short[nr]; 

	while(viter(ve))
    {
		if( sol.IsFG(ve) )
        {
            solptr = sol.GetValuePtr(ve)+sol_off;
            defptr = def.GetValuePtr(ve)+def_off;
            matptr = A.GetDiagValuePtr(ve);
            SparseBlockMCopyDense(decomp,sb,matptr);
            if(LR_Decomp(nr,decomp,pivotmap)) assert(0);
            if(LR_Solve(nr,decomp,pivotmap,solptr,defptr)) assert(0);
        }
#ifdef USE_UG_DS
		else
		{
			// set coarse components to 0
			SparseBlockVSet(svsol,sol.GetValuePtr(ve),0.0);
		}
#endif
    }

    delete decomp;
    delete pivotmap;
	
	return;
}
Пример #9
0
void CopyValue( VT &dest, const VT &source )
{
	// typename is a new C++ keyword!
	typename VT::Iterator viter(dest); 
	typename VT::VectorEntry ve; 
	
	if( &dest == &source )
		return; // nothing to do
	
	while(viter(ve))
		dest[ve] = source[ve];
}	
Пример #10
0
void JacobiSmoothFG( VT &sol, const MT &M, const VT &def )
// changes only the fine unknowns
// result in sol_vec; def_vec: correct defect before call, after call destroyed
{
	typename VT::Iterator viter(sol); 
	typename VT::VectorEntry ve; 

#ifdef USE_UG_DS
	while(viter(ve))
		if( sol.IsFG(ve) )
			sol[ve] = def[ve] / M.DiagValue(ve);
		else
			sol[ve] = 0;	// init other components
#else
	while(viter(ve))
		if( sol.IsFG(ve) )
			sol[ve] += def[ve] / M.DiagValue(ve);
#endif

	return;
}
Пример #11
0
double sum( const VT& v )
{
	// typename is a new C++ keyword!
	typename VT::Iterator viter(v); 
	typename VT::VectorEntry ve; 
	register double res=0.0;
	
	while(viter(ve))
		res += v[ve];
	
	return res;
}
Пример #12
0
void dampedJacobiSmoother( VT &sol, const MT &M, const VT &def )
// result in sol_vec; def_vec: correct defect before call, after call destroyed
{
    static const double omega = 2.0/3.0;

	typename VT::Iterator viter(sol); 
	typename VT::VectorEntry ve; 

	while(viter(ve))
		sol[ve] += omega * def[ve] / M.DiagValue(ve);

	return;
}
Пример #13
0
double sum( const VT& v )
{
    assert(0);// todo: adapt to sparse matrix
	// typename is a new C++ keyword!
	typename VT::Iterator viter(v); 
	typename VT::VectorEntry ve; 
	register double res=0.0;
	
	while(viter(ve))
		res += v[ve];
	
	return res;
}
Пример #14
0
void Scale( VT &v, double scale )
{
	// typename is a new C++ keyword!
	typename VT::Iterator viter(v); 
	typename VT::VectorEntry ve; 
	short ncmp = v.GetSparseVectorPtr()->Get_n();
	short *comp = v.GetSparseVectorPtr()->Get_comp();
    double *vptr;
    
	while(viter(ve))
    {
        vptr = v.GetValuePtr(ve);
        for(short i = 0; i < ncmp; i++) vptr[comp[i]] *= scale;
    }
}
Пример #15
0
double ScalProd( const VT& v, const VT& w )
{
	// typename is a new C++ keyword!
	typename VT::Iterator viter(v); 
	typename VT::VectorEntry ve; 
	register double res=0.0;
	
	while(viter(ve))
		res += v[ve]*w[ve]; 
	
#ifdef ModelP
	res = UG_GlobalSumDOUBLE( res );
#endif

	return res;
}
Пример #16
0
void MatVec( VT &dest, const MT &M, const VT &source )
{
	typename VT::Iterator viter(dest); 
	typename VT::VectorEntry row; 
	typename MT::MatrixEntry col; 
	register double sum;
	
	while(viter(row))
	{
		typename MT::Iterator miter(M,row);
		
		sum = 0.0;
		while(miter(col))
			sum += M[col] * source[col.dest()];
		dest[row] = sum;
	}
}
Пример #17
0
void VecMinusMatVec( VT &d, const VT &f, const MT &M, const VT &u )
{
	typename VT::Iterator viter(d); 
	typename VT::VectorEntry row; 
	typename MT::MatrixEntry col; 
	register double sum;
	
	while(viter(row))
	{
		typename MT::Iterator miter(M,row);
		
		sum = 0.0;
		while(miter(col))
			sum += M[col] * u[col.dest()];
		d[row] = f[row] - sum;
	}
}
Пример #18
0
void VecMinusMatVec( VT &d, const VT &f, const MT &M, const VT &u )
{
	typename VT::Iterator viter(d); 
	typename VT::VectorEntry row; 
	typename MT::MatrixEntry col; 
	double *dptr, *fptr, *uptr, *mptr;
	const FAMGSparseVector *svu  = u.GetSparseVectorPtr();
	const FAMGSparseVector *svf  = f.GetSparseVectorPtr();
	const FAMGSparseVector *svd  = d.GetSparseVectorPtr();
	const FAMGSparseBlock *sb  = M.GetSparseBlockPtr();
    const FAMGSparseBlock *sbd  = M.GetDiagSparseBlockPtr();
    FAMGSparseVector svsum_d, svsum_o;

    svsum_d.Product(sbd,svu);
    svsum_o.Product(sb,svu);

    double *sum_d = new double[svsum_d.Get_maxcomp()+1];
    double *sum_o = new double[svsum_o.Get_maxcomp()+1];
	
	while(viter(row))
	{
		typename MT::Iterator miter(M,row);
		
        dptr = d.GetValuePtr(row);
        fptr = f.GetValuePtr(row);
        
        // diagonal 
        miter(col);
        uptr = u.GetValuePtr(col.dest());
        mptr = M.GetValuePtr(col);
        SparseBlockVSet(&svsum_d,sum_d,0.0);
        SparseBlockVSet(&svsum_o,sum_o,0.0);
        SparseBlockMVAddProduct(&svsum_d,sbd,svu,sum_d,mptr,uptr,1.0);
		while(miter(col))
        {
            uptr = u.GetValuePtr(col.dest());
            mptr = M.GetValuePtr(col);
            SparseBlockMVAddProduct(&svsum_o,sb,svu,sum_o,mptr,uptr,1.0);
        }
        SparseBlockVSub(svd,svf,&svsum_o,dptr,fptr,sum_o);
        SparseBlockVSub(svd,svd,&svsum_d,dptr,dptr,sum_d);
	}

    delete sum_d;
    delete sum_o;
}
Пример #19
0
double norm( const VT& v )
{
	// typename is a new C++ keyword!
	typename VT::Iterator viter(v); 
	typename VT::VectorEntry ve; 
	register double val, res=0.0;
	
	while(viter(ve))
	{
		val = v[ve];
		res += val*val; 
	}
	
#ifdef ModelP
	res = UG_GlobalSumDOUBLE( res );
#endif
	
	return sqrt(res);
}
Пример #20
0
void PolygonView::slotApplyColor() {
  EM_CERR("Polygonview::slotApplyColor");
  bool bVertex = false;
	
  // change selected vertex
  Q3ListViewItemIterator viter(p_VertexListView);
  for (; viter.current(); ++viter) {
    if (viter.current()->isSelected()) {
      bVertex = true;
      if (((ListItem*)viter.current())->getObjectType() == LISTITEM_VERTEX) {
	// 				Color * color = poly->getColor((*coloritem).second);
	// 				assert(color != NULL);
	// 				color->r = p_EditR->text().toFloat();
	// 				color->g = p_EditG->text().toFloat();
	// 				color->b = p_EditB->text().toFloat();
	// 				color->a = p_EditA->text().toFloat();
	EM_CERR("PolygonView::slotApplyColor vertex");
      }
    }
  }

  // change selected polygon only if no vertex was selected
  Q3ListViewItemIterator piter(p_PolygonListView);
  for (; piter.current() && !bVertex; ++piter) {
    if (piter.current()->isSelected()) {
      if (((ListItem*)piter.current())->getObjectType() == LISTITEM_POLYGON) {
				Polygon3D * poly = (Polygon3D*)((ListItem*)piter.current())->getObject();
				assert(poly != NULL);
				poly->setColor(p_EditR->text().toFloat(), 
											 p_EditG->text().toFloat(),
											 p_EditB->text().toFloat(), 
											 p_EditA->text().toFloat());
				EM_CERR("PolygonView::slotApplyColor polygon");
      }
    }
  }

  p_Doc->updateAll("polygon");
}
Пример #21
0
void AddScaledValue( VT &dest, double scale, const VT &source )
{
    // not really tesyed
	// typename is a new C++ keyword!
	typename VT::Iterator viter(dest); 
	typename VT::VectorEntry ve; 
	short ncmp_d = dest.GetSparseVectorPtr()->Get_n();
	short ncmp_s = source.GetSparseVectorPtr()->Get_n();
	short *comp_d = dest.GetSparseVectorPtr()->Get_comp();
 	short *comp_s = source.GetSparseVectorPtr()->Get_comp();
    short ncmp;
    double *vptr_d, *vptr_s;
	
    ncmp = Min(ncmp_d,ncmp_s);

	while(viter(ve))
    {
        vptr_d = dest.GetValuePtr(ve);
        vptr_s = source.GetValuePtr(ve);
		for(short i = 0; i < ncmp; i++) vptr_d[comp_d[i]] += scale*vptr_s[comp_s[i]];
    }
}
Пример #22
0
void JacobiSmoothFGSimple( VT &sol, const MT &D, const VT &def )
// changes only the fine unknowns
// result in sol_vec; def_vec: correct defect before call, after call destroyed
{
	typename VT::Iterator viter(sol); 
	typename VT::VectorEntry ve; 
	const FAMGSparseVector *svsol  = sol.GetSparseVectorPtr();
	const FAMGSparseVector *svdef  = def.GetSparseVectorPtr();
	const FAMGSparseBlock *sb  = D.GetDiagSparseBlockPtr();
	double *solptr, *defptr, *matptr;

	while(viter(ve))
    {
		if( sol.IsFG(ve) )
        {
            solptr = sol.GetValuePtr(ve);
            defptr = def.GetValuePtr(ve);
            matptr = D.GetDiagValuePtr(ve);
            SparseBlockMVAddProduct(svsol,sb,svdef,solptr,matptr,defptr,1.0);
        }
    }
	
	return;
}
Пример #23
0
VRange<Unit *> UncheckedModelImpl::units() const {
  VIter<Unit *> begin = viter(castingIter<Unit *>(mUnits.begin()));
  VIter<Unit *> end = viter(castingIter<Unit *>(mUnits.end()));
  return vrange(begin, end);
}
Пример #24
0
int ConstructGalerkinMatrix( MT &Mcg, const FAMGGrid &fg )
// this matrix lives on the coarse grid
// calculates Mcg := R * Mfg * P and with indices:
// Mcg_(i,j) := \sum_{s,t} R_(i,s) * Mfg_(s,t) * P_(t,j)
{
	typedef typename MT::Vector VT;
	
	const FAMGTransfer &transfer = *fg.GetTransfer();
	
	const typename MT::GridVector& fg_gridvec = (typename MT::GridVector&)fg.GetGridVector();
	const MT& Mfg = (MT&)*fg.GetConsMatrix();	// consistent matrix is essential here!
	const MT& Dfg = (MT&)*fg.GetDiagMatrix();
	const VT &tvA = *fg.GetVector(FAMGTVA);
	const VT &tvB = *fg.GetVector(FAMGTVB);
	typename MT::MatrixEntry mij, mis;
	typename VT::VectorEntry i_fg, i_cg, j_fg, j_cg, s_fg, s_cg, t_cg;
	FAMGTransferEntry *pjs, *pij, *pst;
	typename VT::Iterator viter(fg_gridvec);

#ifdef ModelP
	abort();// check the consistent mode of ALL occuring matrices!!! and remove this line then
#endif
    
    // cast because GetSparseBlockPtr returns a const FAMGSparseBlock * pointer
    FAMGSparseBlock *cmatsb_d = (FAMGSparseBlock *)Mcg.GetDiagSparseBlockPtr();
    FAMGSparseBlock *cmatsb_o = (FAMGSparseBlock *)Mcg.GetSparseBlockPtr();

    const FAMGSparseBlock *dmatsb = Dfg.GetDiagSparseBlockPtr();
    const FAMGSparseBlock *fmatsb_o = Mfg.GetSparseBlockPtr();
    const FAMGSparseBlock *fmatsb_d = Mfg.GetDiagSparseBlockPtr();
    const FAMGSparseVector *sp = transfer.Get_sp();
    const FAMGSparseVector *sr = transfer.Get_sr();
    const FAMGSparseVector *tvAsv = tvA.GetSparseVectorPtr();
    const FAMGSparseVector *tvBsv = tvB.GetSparseVectorPtr();
    double *tvAptr, *tvBptr; 

    FAMGSparseBlock sb_o_p, sb_r_o, sb_r_o_p, sb_r_d_p, sb_r_dmat_p; // only offdiagonal blocks

    sb_o_p.Product(fmatsb_o,sp);
    sb_r_o.Product(sr,fmatsb_o);
    sb_r_o_p.Product(sr,fmatsb_o,sp);
    // sb_r_dmat_p.Product(sr,dmatsb,sp);
    sb_r_dmat_p = (*fmatsb_o);
    sb_r_d_p.Product(sr,fmatsb_d,sp);
    

    // chech sparse block structure
    if(cmatsb_o->CheckStructureforAdd(fmatsb_o)) return 1;
    if(cmatsb_o->CheckStructureforAdd(&sb_o_p)) return 1;
    if(cmatsb_o->CheckStructureforAdd(&sb_r_o)) return 1;
    if(cmatsb_o->CheckStructureforAdd(&sb_r_o_p)) return 1;
    if(cmatsb_o->CheckStructureforAdd(&sb_r_dmat_p)) return 1;
    if(cmatsb_d->CheckStructureforAdd(fmatsb_d)) return 1;
    if(cmatsb_d->CheckStructureforAdd(&sb_r_d_p)) return 1;
    if(cmatsb_d->CheckStructureforAdd(&sb_o_p)) return 1;
    if(cmatsb_d->CheckStructureforAdd(&sb_r_o)) return 1;
    if(cmatsb_d->CheckStructureforAdd(&sb_r_o_p)) return 1;
    if(cmatsb_d->CheckStructureforAdd(&sb_r_dmat_p)) return 1;


    short maxoffset = sb_o_p.Get_maxoffset();
    maxoffset = Max(maxoffset,sb_r_o.Get_maxoffset());
    maxoffset = Max(maxoffset,sb_r_o_p.Get_maxoffset());
    maxoffset = Max(maxoffset,sb_r_dmat_p.Get_maxoffset());
    maxoffset = Max(maxoffset,sb_r_d_p.Get_maxoffset());

    double *val = new double[maxoffset+1];
    double *diaginv = new double[dmatsb->Get_maxoffset()+1];


	while (viter(i_fg) )
	{
#ifdef ModelP
		if ( IS_FAMG_GHOST(((FAMGugVectorEntryRef*)(i_fg.GetPointer()))->myvector()) )
		{
			// repair coarse grid matrix of border vector, if it has no diagonal matrix entry
			if (fg_gridvec.IsCG(i_fg) )
			{
				transfer.GetFirstEntry(i_fg)->GetColInVar(i_cg);

				typename MT::Iterator mijiter(Mcg,i_cg);

				if( mijiter(mij) )	// test first matrix entry of i_cg
				{
					if( mij.dest() != i_cg )
						Mcg.AddEntry(0.0, i_cg, i_cg);	// has no diag entry yet
				}
				else // i_cg has no matrix entry
				{
					Mcg.AddEntry(0.0, i_cg, i_cg);
				}
			}
			continue;
		}
#endif

		// i is now in core partition

		if (fg_gridvec.IsCG(i_fg) )
		{
			// i is coarse
		
			transfer.GetFirstEntry(i_fg)->GetColInVar(i_cg);
			
			typename MT::Iterator mijiter(Mfg,i_fg);
			while( mijiter(mij) )
			{
				j_fg = mij.dest();
				
				if( fg_gridvec.IsCG(j_fg) )
				{
					transfer.GetFirstEntry(j_fg)->GetColInVar(j_cg);
					// Mcg.AddEntry(Mfg[mij], i_cg, j_cg);               // Mcc
					if(i_cg == j_cg) Mcg.AddEntry(fmatsb_d,Mfg.GetValuePtr(mij), i_cg, j_cg);
                    else Mcg.AddEntry(fmatsb_o,Mfg.GetValuePtr(mij), i_cg, j_cg);    // Mcc
				}
				else
				{
					for( pjs=transfer.GetFirstEntry(j_fg); pjs != NULL; pjs = pjs->GetNext())
					{
						pjs->GetColInVar(s_cg);
                        SparseBlockMMProduct(&sb_o_p,fmatsb_o,sp,val,Mfg.GetValuePtr(mij),pjs->GetProlongationPtr());
                        Mcg.AddEntry(&sb_o_p,val,i_cg, s_cg);

						// Mcg.AddEntry(Mfg[mij]*pjs->GetProlongation(), i_cg, s_cg);      // Mcf*P
					}
				}
			}
		}
		else
		{
			// i is fine

			typename MT::Iterator misiter(Mfg,i_fg);
			while( misiter(mis) )
			{
				s_fg = mis.dest();

				for( pij=transfer.GetFirstEntry(i_fg); pij != NULL; pij = pij->GetNext())
				{
					pij->GetColInVar(j_cg);

					if( fg_gridvec.IsCG(s_fg) )
					{
						transfer.GetFirstEntry(s_fg)->GetColInVar(s_cg);
						// pij is equivalent to rji 
						// Mcg.AddEntry(pij->GetRestriction()*Mfg[mis], j_cg, s_cg);          // R*Mfc
                         SparseBlockMMProduct(&sb_r_o,sr,fmatsb_o,val,pij->GetRestrictionPtr(),Mfg.GetValuePtr(mis));
                         Mcg.AddEntry(&sb_r_o,val,j_cg, s_cg);
                       
					}
					else
					{
                        // s is fine 
                        if(s_fg == i_fg)
                        {
                            // special treatment for the A_{i,i} to keep block sparsity pattern  
                            for( pst=transfer.GetFirstEntry(s_fg); pst != NULL; pst = pst->GetNext())
                            {
                                pst->GetColInVar(t_cg);
                                // pij is equivalent to rji
                                // Mcg.AddEntry(pij->GetRestriction()*Mfg[mis]*pst->GetProlongation(), j_cg, t_cg);// R*Mff*P
                                SparseBlockMMProduct(&sb_r_d_p,sr,fmatsb_d,sp,val,pij->GetRestrictionPtr(),Mfg.GetValuePtr(mis),pst->GetProlongationPtr());
                                //Mcg.AddEntry(&sb_r_d_p,val,j_cg, j_cg); // lump to diagonal
                                Mcg.AddEntry(&sb_r_d_p,val,t_cg, t_cg); // lump to diagonal
                                
                                // todo: make sure lumping preserves filter condition
                                if(j_cg != t_cg)
                                {
                                    // SparseBlockMInvertDiag(dmatsb, diaginv, Dfg.GetValuePtr(mis));
                                    // SparseBlockMMProduct(&sb_r_dmat_p,sr,dmatsb,sp,val,pij->GetRestrictionPtr(),diaginv,pst->GetProlongationPtr());
                                    tvAptr = tvA.GetValuePtr(t_cg); tvBptr = tvB.GetValuePtr(t_cg);
                                    SparseBlockGalDiagApprox(&sb_r_dmat_p,sr,fmatsb_d,sp,tvAsv,val,pij->GetRestrictionPtr(),Mfg.GetValuePtr(mis),pst->GetProlongationPtr(),tvAptr);
                                    // SparseBlockGalDiagApproxT(&sb_r_dmat_p,sr,fmatsb_d,sp,tvBsv,val,pij->GetRestrictionPtr(),Mfg.GetValuePtr(mis),pst->GetProlongationPtr(),tvBptr);
                                    Mcg.AddEntry(&sb_r_dmat_p,val,j_cg, t_cg); 
                                    // Mcg.AddEntry(&sb_r_dmat_p,val,j_cg, j_cg,-1.0); 
                                    Mcg.AddEntry(&sb_r_dmat_p,val,t_cg, t_cg,-1.0); 
                                }
                                
                            }
						}
                        else
                        {
                            for( pst=transfer.GetFirstEntry(s_fg); pst != NULL; pst = pst->GetNext())
                            {
                                pst->GetColInVar(t_cg);
                                // pij is equivalent to rji
                                // Mcg.AddEntry(pij->GetRestriction()*Mfg[mis]*pst->GetProlongation(), j_cg, t_cg);// R*Mff*P
                                SparseBlockMMProduct(&sb_r_o_p,sr,fmatsb_o,sp,val,pij->GetRestrictionPtr(),Mfg.GetValuePtr(mis),pst->GetProlongationPtr());
                                Mcg.AddEntry(&sb_r_o_p,val,j_cg, t_cg);
                            }
                        }
					}
				}
				
			}
		}
	}

    delete val;
    delete diaginv;

	return 0;
}
Пример #25
0
void MarkStrongLinks(const MT &A, const FAMGGrid &grid)
{
	typedef typename MT::Vector VT;
	const typename MT::GridVector& gridvec = (typename MT::GridVector&)grid.GetGridVector();
	typename MT::MatrixEntry matij;
	typename VT::VectorEntry vi;
	typename VT::Iterator viter(gridvec);

    double rlist[20], llist[20], mij, mji, rmax, lmax;
    int z, y;
    const double sigma = FAMGGetParameter()->Getsigma();
    const int minsl = 2 - 1;

	while (viter(vi))
	{
        for(z = 0; z <= minsl; z++)
        {
            rlist[z] = llist[z] = 0.0;
        }

        typename MT::Iterator mij_iter(A,vi);
        mij_iter(matij); // skip diagonal
        while( mij_iter(matij) )
        {
            mij = Abs(A[matij]);
            mji = Abs(A.GetAdjData(matij));

            for(z = minsl; z >= 0; z--)
            {
                if (mij < rlist[z]) break;
            }
            for(y = minsl; y > z+1; y--)
            { 
                rlist[y] = rlist[y-1];
            }
            if(z+1 <= minsl) rlist[z+1] = mij;

            for(z = minsl; z >= 0; z--)
            {
                if (mji < llist[z]) break;
            }
            for(y = minsl; y > z+1; y--)
            { 
                llist[y] = llist[y-1];
            }
            if(z+1 <= minsl) llist[z+1] = mji;            
        }

        rmax = rlist[minsl]*sigma; 
        lmax = llist[minsl]*sigma; 

        mij_iter.reset();
        mij_iter(matij);
        matij.set_strong(1);
        while( mij_iter(matij) )
        {
            mij = Abs(A[matij]);
            mji = Abs(A.GetAdjData(matij));
            if((mij > rmax) || (mji > lmax)) 
            {
                matij.set_strong(1);
            }
            else matij.set_strong(0);
        }

    }
    
	return;
}
Пример #26
0
int ConstructGalerkinMatrix( MT &Mcg, const FAMGGrid &fg )
// this matrix lives on the coarse grid
// calculates Mcg := R * Mfg * P and with indices:
// Mcg_(i,j) := \sum_{s,t} R_(i,s) * Mfg_(s,t) * P_(t,j)
{
	typedef typename MT::Vector VT;
	
	const FAMGTransfer &transfer = *fg.GetTransfer();
	
	const typename MT::GridVector& fg_gridvec = (typename MT::GridVector&)fg.GetGridVector();
	const MT& Mfg = (MT&)*fg.GetConsMatrix();	// consistent matrix is essential here!
	typename MT::MatrixEntry mij, mis;
	typename VT::VectorEntry i_fg, i_cg, j_fg, j_cg, s_fg, s_cg, t_cg;
	FAMGTransferEntry *pjs, *pij, *pst;

	typename VT::Iterator viter(fg_gridvec);

// the next lines are for debugging only:
//MATDATA_DESC *tmpA = ((FAMGugMatrix*)fg.GetConsMatrix())->GetMatDesc();
//GRID *tmpgrid = fg.GetugGrid();
//int tmpflevel = GLEVEL(tmpgrid);
//printf("%d: GalerkinAss finelevel = %d\n",me,tmpflevel); prvGeom(tmpflevel,0); primGeom(tmpflevel); prmGeom(tmpflevel,MD_SCALCMP(tmpA)); prvGeom(tmpflevel-1,0);

	while (viter(i_fg) )
	{
#ifdef ModelP
		if ( IS_FAMG_GHOST(((FAMGugVectorEntryRef*)(i_fg.GetPointer()))->myvector()) )
		{
			// repair coarse grid matrix of border vector, if it has no diagonal matrix entry
			if (fg_gridvec.IsCG(i_fg) )
			{
				transfer.GetFirstEntry(i_fg)->GetColInVar(i_cg);

				typename MT::Iterator mijiter(Mcg,i_cg);

				if( mijiter(mij) )	// test first matrix entry of i_cg
				{
					if( mij.dest() != i_cg )
						Mcg.AddEntry(0.0, i_cg, i_cg);	// has no diag entry yet
				}
				else // i_cg has no matrix entry
				{
					Mcg.AddEntry(0.0, i_cg, i_cg);
				}
			}
			continue;
		}
#endif

		// i is now in core partition

		if (fg_gridvec.IsCG(i_fg) )
		{
			// i is coarse
		
			transfer.GetFirstEntry(i_fg)->GetColInVar(i_cg);
			
			typename MT::Iterator mijiter(Mfg,i_fg);
			while( mijiter(mij) )
			{
				j_fg = mij.dest();
				
				if( fg_gridvec.IsCG(j_fg) )
				{
					transfer.GetFirstEntry(j_fg)->GetColInVar(j_cg);
					Mcg.AddEntry(Mfg[mij], i_cg, j_cg);               // Mcc
					//printf("%d: G%d[%d] Mcc i f%d[%d] c%d[%d] j f%d[%d] c%d[%d] Mfg[mij]=%g\n",me, prvec(i_cg),
					//	prvec(i_fg),prvec(i_cg),prvec(j_fg),prvec(j_cg),Mfg[mij]);
				}
				else
				{
					for( pjs=transfer.GetFirstEntry(j_fg); pjs != NULL; pjs = pjs->GetNext())
					{
						pjs->GetColInVar(s_cg);
						Mcg.AddEntry(Mfg[mij]*pjs->GetProlongation(), i_cg, s_cg);      // Mcf*P
						//printf("%d: G%d[%d] Mcf*P i f%d[%d] c%d[%d] j f%d[%d] s c%d[%d] Mfg[mij]=%g pjs=%g Mfg[mij]*pjs=%g\n",me, prvec(i_cg),
						//	prvec(i_fg),prvec(i_cg),prvec(j_fg),prvec(s_cg),Mfg[mij],pjs->GetProlongation(),Mfg[mij]*pjs->GetProlongation());

					}
				}
			}
		}
		else
		{
			// i is fine

			typename MT::Iterator misiter(Mfg,i_fg);
			while( misiter(mis) )
			{
				s_fg = mis.dest();

				for( pij=transfer.GetFirstEntry(i_fg); pij != NULL; pij = pij->GetNext())
				{
					pij->GetColInVar(j_cg);

					if( fg_gridvec.IsCG(s_fg) )
					{
						transfer.GetFirstEntry(s_fg)->GetColInVar(s_cg);
						// pij is equivalent to rji 
						Mcg.AddEntry(pij->GetRestriction()*Mfg[mis], j_cg, s_cg);          // R*Mfc
						//printf("%d: G%d[%d] R*Mfc j c%d[%d] i f%d[%d] s f%d[%d] c%d[%d] rji=%g Mfg[mis]=%g rji*Mfg[mis]=%g\n",me, prvec(j_cg),
						//	prvec(j_cg),prvec(i_fg),prvec(s_fg),prvec(s_cg),pij->GetRestriction(), Mfg[mis], pij->GetRestriction()*Mfg[mis] );
					}
					else
					{	// s is fine 
						for( pst=transfer.GetFirstEntry(s_fg); pst != NULL; pst = pst->GetNext())
						{
							pst->GetColInVar(t_cg);
							// pij is equivalent to rji
							Mcg.AddEntry(pij->GetRestriction()*Mfg[mis]*pst->GetProlongation(), j_cg, t_cg);// R*Mff*P
							//printf("%d: G%d[%d] R*Mff*P j c%d[%d] i f%d[%d] s f%d[%d] t c%d[%d] rji=%g Mfg[mis]=%g pst=%g rji*Mfg[mis]*pst=%g\n",me, prvec(j_cg),
							//	prvec(j_cg),prvec(i_fg),prvec(s_fg),prvec(t_cg),pij->GetRestriction(),Mfg[mis],pst->GetProlongation(),pij->GetRestriction()*Mfg[mis]*pst->GetProlongation() );

						}
					}
				}
				
			}
		}
	}

	return 0;
}
Пример #27
0
bool CXRayObjectExport::initializeSetsAndLookupTables( bool exportAll )
//
// Description :
//    Creates a list of all sets in Maya, a list of mesh objects,
//    and polygon/vertex lookup tables that will be used to
//    determine which sets are referenced by the poly components.
//
{
	int i=0,j=0, length;
	MStatus stat;
	
	// Initialize class data.
	// Note: we cannot do this in the constructor as it
	// only gets called upon registry of the plug-in.
	//
	numSets = 0;
	sets = NULL;
	lastSets = NULL;
	lastMaterials = NULL;
	objectId = 0;
	objectCount = 0;
	polygonTable = NULL;
	vertexTable = NULL;
	polygonTablePtr = NULL;
	vertexTablePtr = NULL;
	objectGroupsTablePtr = NULL;
	objectNodeNamesArray.clear();
	transformNodeNameArray.clear();

	//////////////////////////////////////////////////////////////////
	//
	// Find all sets in Maya and store the ones we care about in
	// the 'sets' array. Also make note of the number of sets.
	//
	//////////////////////////////////////////////////////////////////
	
	// Get all of the sets in maya and put them into
	// a selection list
	// 
	MStringArray result;
	MGlobal::executeCommand( "ls -sets", result );
	MSelectionList * setList = new MSelectionList();
	length = result.length();
	for ( i=0; i<length; i++ )
	{	
		setList->add( result[i] );
	}
	
	// Extract each set as an MObject and add them to the
	// sets array.
	// We may be excluding groups, matierials, or ptGroups
	// in which case we can ignore those sets. 
	//
	MObject mset;
	sets = new MObjectArray();
	length = setList->length();
	for ( i=0; i<length; i++ )
	{
		setList->getDependNode( i, mset );
		
		MFnSet fnSet( mset, &stat );
		if ( stat ) {
			if ( MFnSet::kRenderableOnly == fnSet.restriction(&stat) ) {
				sets->append( mset );
			}
		}	
	}
	xr_delete(setList);
	
	numSets = sets->length();
			
	//////////////////////////////////////////////////////////////////
	//
	// Do a dag-iteration and for every mesh found, create facet and
	// vertex look-up tables. These tables will keep track of which
	// sets each component belongs to.
	//
	// If exportAll is false then iterate over the activeSelection 
	// list instead of the entire DAG.
	//
	// These arrays have a corrisponding entry in the name
	// stringArray.
	//
	//////////////////////////////////////////////////////////////////
	MIntArray vertexCounts;
	MIntArray polygonCounts;	
			
	if ( exportAll ) {
		MItDag dagIterator( MItDag::kBreadthFirst, MFn::kInvalid, &stat);

    	if ( MS::kSuccess != stat) {
    	    fprintf(stderr,"Failure in DAG iterator setup.\n");
    	    return false;
    	}
		
		objectNames = new MStringArray();
		
    	for ( ; !dagIterator.isDone(); dagIterator.next() ) 
		{
    	    MDagPath dagPath;
    	    stat = dagIterator.getPath( dagPath );

			if ( stat ) 
			{
				// skip over intermediate objects
				//
				MFnDagNode dagNode( dagPath, &stat );
				if (dagNode.isIntermediateObject()) 
				{
					continue;
				}

				if (( dagPath.hasFn(MFn::kMesh)) &&
					( dagPath.hasFn(MFn::kTransform)))
				{
					// We want only the shape, 
					// not the transform-extended-to-shape.
					continue;
				}
				else if ( dagPath.hasFn(MFn::kMesh))
				{
					// We have a mesh so create a vertex and polygon table
					// for this object.
					//
					MFnMesh fnMesh( dagPath );
					int vtxCount = fnMesh.numVertices();
					int polygonCount = fnMesh.numPolygons();
					// we do not need this call anymore, we have the shape.
					// dagPath.extendToShape();
					MString name = dagPath.fullPathName();
					objectNames->append( name );
					objectNodeNamesArray.append( fnMesh.name() );

					vertexCounts.append( vtxCount );
					polygonCounts.append( polygonCount );

					objectCount++;
				}
			}
		}	
	}else{
		MSelectionList slist;
    	MGlobal::getActiveSelectionList( slist );
    	MItSelectionList iter( slist );
		MStatus status;

		objectNames = new MStringArray();

		// We will need to interate over a selected node's heirarchy
		// in the case where shapes are grouped, and the group is selected.
		MItDag dagIterator( MItDag::kDepthFirst, MFn::kInvalid, &status);

    	for ( ; !iter.isDone(); iter.next() ){
			MDagPath objectPath;
			stat = iter.getDagPath( objectPath );

			// reset iterator's root node to be the selected node.
			status = dagIterator.reset (objectPath.node(), 
										MItDag::kDepthFirst, MFn::kInvalid );

			// DAG iteration beginning at at selected node
			for ( ; !dagIterator.isDone(); dagIterator.next() ){
				MDagPath dagPath;
				MObject  component = MObject::kNullObj;
				status = dagIterator.getPath(dagPath);

				if (!status){
					fprintf(stderr,"Failure getting DAG path.\n");
					freeLookupTables();
					return false;
				}

                // skip over intermediate objects
                //
                MFnDagNode dagNode( dagPath, &stat );
                if (dagNode.isIntermediateObject()) continue;

				if (( dagPath.hasFn(MFn::kMesh)) && ( dagPath.hasFn(MFn::kTransform))){
					// We want only the shape, 
					// not the transform-extended-to-shape.
					continue;
				}else if ( dagPath.hasFn(MFn::kMesh)){
					// We have a mesh so create a vertex and polygon table
					// for this object.
					//
					MFnMesh fnMesh( dagPath );
					int vtxCount = fnMesh.numVertices();
					int polygonCount = fnMesh.numPolygons();

					// we do not need this call anymore, we have the shape.
					// dagPath.extendToShape();
					MString name = dagPath.fullPathName();
					objectNames->append( name );
					objectNodeNamesArray.append( fnMesh.name() );
									
					vertexCounts.append( vtxCount );
					polygonCounts.append( polygonCount );

					objectCount++;	
				}
    		}
		}
	}

	// Now we know how many objects we are dealing with 
	// and we have counts of the vertices/polygons for each
	// object so create the maya group look-up table.
	//
	if( objectCount > 0 ) {
		// To export Maya groups we traverse the hierarchy starting at
		// each objectNodeNamesArray[i] going towards the root collecting transform
		// nodes as we go.
		length = objectNodeNamesArray.length();
		for( i=0; i<length; i++ ) {
			MIntArray transformNodeNameIndicesArray;
			recFindTransformDAGNodes( objectNodeNamesArray[i], transformNodeNameIndicesArray );
		}

		if( transformNodeNameArray.length() > 0 ) {
			objectGroupsTablePtr = xr_alloc<bool*>(objectCount);// (bool**) malloc( sizeof(bool*)*objectCount );
			length = transformNodeNameArray.length();
			for ( i=0; i<objectCount; i++ )
			{
//				objectGroupsTablePtr[i] = (bool*)calloc( length, sizeof(bool) );	
				objectGroupsTablePtr[i] = xr_alloc<bool>(length);
				ZeroMemory(objectGroupsTablePtr[i],length*sizeof(bool));
                // XXX nitrocaster: remove this 'cause malloc failure shouldn't be handled there
				if ( objectGroupsTablePtr[i] == NULL ) {
					Log("! calloc returned NULL (objectGroupsTablePtr)");
					return false;
				}
			}
		}
//		else{
//			Log("! Can't find transform for node.");
//			return false;
//		}
	}

	// Create the vertex/polygon look-up tables.
	//
	if ( objectCount > 0 ) {
		
		vertexTablePtr = xr_alloc<bool*>(objectCount);	//(bool**) malloc( sizeof(bool*)*objectCount );
		polygonTablePtr = xr_alloc<bool*>(objectCount);	//(bool**) malloc( sizeof(bool*)*objectCount );
	
		for ( i=0; i<objectCount; i++ )
		{
//			vertexTablePtr[i] = (bool*)calloc( vertexCounts[i]*numSets, sizeof(bool) );	
			vertexTablePtr[i] = xr_alloc<bool>(vertexCounts[i]*numSets);
			ZeroMemory(vertexTablePtr[i],vertexCounts[i]*numSets*sizeof(bool));
            // XXX nitrocaster: remove this 'cause malloc failure shouldn't be handled there
			if ( vertexTablePtr[i] == NULL ) {
				Log("! calloc returned NULL (vertexTable)");
				return false;
			}
	
//			polygonTablePtr[i] = (bool*)calloc( polygonCounts[i]*numSets, sizeof(bool) );
			polygonTablePtr[i] = xr_alloc<bool>(polygonCounts[i]*numSets);
			ZeroMemory(polygonTablePtr[i],polygonCounts[i]*numSets*sizeof(bool));
            // XXX nitrocaster: remove this 'cause malloc failure shouldn't be handled there
			if ( polygonTablePtr[i] == NULL ) {
				Log("! calloc returned NULL (polygonTable)");
				return false;
			}
		}	
	}

	// If we found no meshes then return
	//	
	if ( objectCount == 0 ) {
		return false;
	}
	
	//////////////////////////////////////////////////////////////////
	//
	// Go through all of the set members (flattened lists) and mark
	// in the lookup-tables, the sets that each mesh component belongs
	// to.
	//
	//
	//////////////////////////////////////////////////////////////////
	bool flattenedList = true;
	MDagPath object;
	MObject component;
	MSelectionList memberList;
	
	
	for ( i=0; i<numSets; i++ )
	{
		MFnSet fnSet( (*sets)[i] );		
		memberList.clear();
		stat = fnSet.getMembers( memberList, flattenedList );

		if (MS::kSuccess != stat) {
			fprintf(stderr,"Error in fnSet.getMembers()!\n");
		}

		int m, numMembers;
		numMembers = memberList.length();
		for ( m=0; m<numMembers; m++ )
		{
			if ( memberList.getDagPath(m,object,component) ) {

				if ( (!component.isNull()) && (object.apiType() == MFn::kMesh) )
				{
					if (component.apiType() == MFn::kMeshVertComponent) {
						MItMeshVertex viter( object, component );	
						for ( ; !viter.isDone(); viter.next() )
						{
							int compIdx = viter.index();
							MString name = object.fullPathName();
							
							// Figure out which object vertexTable
							// to get.
							//

							int o, numObjectNames;
							numObjectNames = objectNames->length();
							for ( o=0; o<numObjectNames; o++ ) {
								if ( (*objectNames)[o] == name ) {
									// Mark set i as true in the table
									//		
									vertexTable = vertexTablePtr[o];
									*(vertexTable + numSets*compIdx + i) = true;
									break;
								}
							}
						}
					}
					else if (component.apiType() == MFn::kMeshPolygonComponent) 
					{
						MItMeshPolygon piter( object, component );
						for ( ; !piter.isDone(); piter.next() )
						{
							int compIdx = piter.index();
							MString name = object.fullPathName();
							
							// Figure out which object polygonTable
							// to get.
							//							
							int o, numObjectNames;
							numObjectNames = objectNames->length();
							for ( o=0; o<numObjectNames; o++ ) {
								if ( (*objectNames)[o] == name ) {
									
									// Mark set i as true in the table
									//

									// Check for bad components in the set
									//									
									if ( compIdx >= polygonCounts[o] ) {
										Msg("! Bad polygon index '%d' found. Polygon skipped",compIdx);
										break;
									}
									
									polygonTable = polygonTablePtr[o];
									*(polygonTable + numSets*compIdx + i) = true;
									break;
								}
							}	
						}
					}										
				}
				else { 

				// There are no components, therefore we can mark
				// all polygons as members of the given set.
				//

				if (object.hasFn(MFn::kMesh)) {

					MFnMesh fnMesh( object, &stat );
					if ( MS::kSuccess != stat) {
						fprintf(stderr,"Failure in MFnMesh initialization.\n");
						return false;
					}

					// We are going to iterate over all the polygons.
					//
					MItMeshPolygon piter( object, MObject::kNullObj, &stat );
					if ( MS::kSuccess != stat) {
						fprintf(stderr,
								"Failure in MItMeshPolygon initialization.\n");
						return false;
					}
					for ( ; !piter.isDone(); piter.next() )
					{
						int compIdx = piter.index();
						MString name = object.fullPathName();

						// Figure out which object polygonTable to get.
						//
						int o, numObjectNames;
						numObjectNames = objectNames->length();
						for ( o=0; o<numObjectNames; o++ ) {
							if ( (*objectNames)[o] == name ) {
								// Check for bad components in the set
								//
								if ( compIdx >= polygonCounts[o] ) {
									Msg("! Bad polygon index '%d' found. Polygon skipped",compIdx);
									break;
								}
								// Mark set i as true in the table
								//
								polygonTable = polygonTablePtr[o];
								*(polygonTable + numSets*compIdx + i) = true;
								break;
							}
						}
					} // end of piter.next() loop
				} // end of condition if (object.hasFn(MFn::kMesh))
				} // end of else condifion if (!component.isNull()) 
			} // end of memberList.getDagPath(m,object,component)
		} // end of memberList loop
	} // end of for-loop for sets

	// Go through all of the group members and mark in the
	// lookup-table, the group that each shape belongs to.
	length = objectNodeNamesArray.length();
	if (objectGroupsTablePtr){
		for( i=0; i<length; i++ ) {
			MIntArray groupTableIndicesArray;
			bool *objectGroupTable = objectGroupsTablePtr[i];
			int length2;
			recFindTransformDAGNodes( objectNodeNamesArray[i], groupTableIndicesArray );
			length2 = groupTableIndicesArray.length();
			for( j=0; j<length2; j++ ) {
				int groupIdx = groupTableIndicesArray[j];
				objectGroupTable[groupIdx] = true;
			}
		}
	}
	return true;
}