C++ CFieldWorld::IsIdEA方法代码示例

bool View::CIndexArrayElem::Set_Hex
(unsigned int id_ea, unsigned int id_es, 
 const Fem::Field::CFieldWorld& world)
{
	if( !world.IsIdEA(id_ea) ) return false;
	const CElemAry& ea = world.GetEA(id_ea);
	if( !ea.IsSegID(id_es) ) return false;
	if( ea.ElemType() != HEX ) return false;
	////////////////
	itype = Fem::Field::HEX;
	this->id_ea = id_ea;
	this->id_es = id_es;
	unsigned int id_es_add = 0;
	CElemAry* pEA = ea.MakeBoundElemAry(id_es,id_es_add,aIndElem);
	nElem = pEA->Size();
	nnoel = 4;
	assert( aIndElem.size() == nElem );
	assert( pEA->IsSegID(id_es_add) );
	const CElemAry::CElemSeg& es = pEA->GetSeg(id_es_add);
	const unsigned int npofa = 4;
	pIA_Elem = new unsigned int [nElem*npofa];
	for(unsigned int iface=0;iface<nElem;iface++){
		es.GetNodes(iface,pIA_Elem+iface*npofa);
	}
	delete pEA;
	return true;
}

// add pattern to the diagonal
bool Ls::CLinearSystem_RigidField2::AddPattern_Field(const unsigned int id_field, const Fem::Field::CFieldWorld& world)
{
	if( !world.IsIdField(id_field) ) return false;
  const Fem::Field::CField& field = world.GetField(id_field);
	unsigned int id_field_parent;
	{
		if( field.GetIDFieldParent() == 0 ){ id_field_parent = id_field; }
		else{ id_field_parent = field.GetIDFieldParent(); }
	}

	const unsigned int nlen_value = field.GetNLenValue();

	int ilss_add;
	{	// Cornerブロックを作る
    unsigned int id_na_val = field.GetNodeSegInNodeAry(Fem::Field::CORNER).id_na_va;
		if( id_na_val != 0 ){
			assert( world.IsIdNA(id_na_val) );
      const Fem::Field::CNodeAry& na = world.GetNA(id_na_val);
      assert( m_ls.GetNLinSysSeg() == this->m_aSegRF.size() );
      ilss_add = m_ls.GetNLinSysSeg();
      this->m_aSegRF.push_back( CLinSysSegRF(id_field_parent,Fem::Field::CORNER) );
      int ires = m_ls.AddLinSysSeg( na.Size(), field.GetNLenValue() );
      assert( ires == ilss_add );
		}
		else{ ilss_add = -1; }
	}
	////////////////////////////////
	const std::vector<unsigned int> aIdEA = field.GetAryIdEA();
  assert( aIdEA.size() > 0 );
	for(unsigned int iiea=0;iiea<aIdEA.size();iiea++){
		const unsigned int id_ea = aIdEA[iiea];
    const Fem::Field::CElemAry& ea = world.GetEA(id_ea);
		// CORNER節点について
    if( field.GetIdElemSeg(id_ea,Fem::Field::CORNER,true,world) != 0 ){
			assert( world.IsIdEA(id_ea) );
      const unsigned int id_es_c = field.GetIdElemSeg(id_ea,Fem::Field::CORNER,true,world);
			assert( ea.IsSegID(id_es_c) );
      {
        Com::CIndexedArray crs;
        ea.MakePattern_FEM(id_es_c,crs);
        m_ls.AddMat_Dia(ilss_add, crs );			// cc行列を作る
      }
      if( field.GetIdElemSeg(id_ea,Fem::Field::BUBBLE,true,world) != 0 ){	// CORNER-BUBBLE
        assert(0);
			}
      if( field.GetIdElemSeg(id_ea,Fem::Field::EDGE,true,world) != 0 ){	// CONRER-EDGE
        assert(0);
			}
		}
		// EDGE節点について
    if( field.GetIdElemSeg(id_ea,Fem::Field::EDGE,true,world) != 0 ){
      assert(0);
		}
		// BUBBLE節点について
    if( field.GetIdElemSeg(id_ea,Fem::Field::BUBBLE,true,world) != 0 ){
      assert(0);
		}
	}
	return true;
}

CIndexArrayElem::CIndexArrayElem(unsigned int id_ea, unsigned int id_es, const Fem::Field::CFieldWorld& world)
{
//	std::cout << "CIndexArrayElem::CIndexArrayElem" << std::endl;
	itype = ELEM_TYPE_NOT_SET; 
	is_selected = false;
	this->id_ea=id_ea;
	this->id_es=id_es;
	color[0] = 0.8; color[1] = 0.8; color[2] = 0.8;
//	color[0] = 1.0; color[1] = 1.0; color[2] = 1.0;  
//	color[0] = 0.8; color[1] = 0.2; color[2] = 0.2;
//	color[0] = 0.2; color[1] = 0.8; color[2] = 0.2;
	nElem = 0;
	pIA_Elem = 0;
	pColor = 0;
	ilayer = 0;
	////////////////
	if( !world.IsIdEA(id_ea) ) return;
	const CElemAry& ea = world.GetEA(id_ea);
	if(      ea.ElemType() == Fem::Field::POINT){ color[0]=0; color[1]=0; color[2]=0; }
	else if( ea.ElemType() == Fem::Field::LINE ){ Set_Line(id_ea,id_es, world); color[0]=0; color[1]=0; color[2]=0; }
	else if( ea.ElemType() == Fem::Field::TRI  ){ Set_Tri( id_ea,id_es, world); }
	else if( ea.ElemType() == Fem::Field::QUAD ){ Set_Quad(id_ea,id_es, world); }
	else if( ea.ElemType() == Fem::Field::TET  ){ Set_Tet( id_ea,id_es, world); }
	else if( ea.ElemType() == Fem::Field::HEX  ){ Set_Hex( id_ea,id_es, world); }
}

/*
bool CEqnSystem_Solid2D::SetDomain_Field(unsigned int id_field_base, Fem::Field::CFieldWorld& world)
{
	{	// ì¸óÕÉtÉBÅ[ÉãÉhÇÃç¿ïWêflì_ÉZÉOÉÅÉìÉgÇÃdofÇ™2ǩǫǧǩÉ`ÉFÉbÉNÇ∑ÇÈ
//		unsigned int id_field_base = world.GetFieldBaseID();
		assert( world.IsIdField(id_field_base) );
		const CField& field_base = world.GetField(id_field_base);
		assert( field_base.GetNDimCoord() == 2 );
	}
	m_IdFieldDisp = world.MakeField_FieldElemDim(id_field_base, 2,
        VECTOR2,VALUE|VELOCITY|ACCELERATION,CORNER);
	const CIDConvEAMshCad conv = world.GetIDConverter(id_field_base);
	{
		m_aEqn.clear();
		const CField& field = world.GetField(m_IdFieldDisp);
		const std::vector<unsigned int>& aIdEA = field.GetAryIdEA();
		for(unsigned int iiea=0;iiea<aIdEA.size();iiea++){
			const unsigned int id_ea = aIdEA[iiea];
			assert( world.IsIdEA(id_ea) );
			const CElemAry& ea = world.GetEA(id_ea);
			if( ea.ElemType() != TRI && ea.ElemType() != QUAD ) continue;
			m_aEqn.push_back( CEqn_Solid2D(id_ea,m_IdFieldDisp) );
		}
	}
	this->ClearLinearSystemPreconditioner();
	this->m_aIdFixField.clear();
	return true;
}
*/
bool CEqnSystem_Solid2D::SetDomain_FieldEA(unsigned int id_field_base, unsigned int id_ea, 
                                           Fem::Field::CFieldWorld& world)
{
	{	// ì¸óÕÉtÉBÅ[ÉãÉhÇÃç¿ïWêflì_ÉZÉOÉÅÉìÉgÇÃdofÇ™2ǩǫǧǩÉ`ÉFÉbÉNÇ∑ÇÈ
//		unsigned int id_field_base = world.GetFieldBaseID();
		assert( world.IsIdField(id_field_base) );
		const CField& field_base = world.GetField(id_field_base);
		assert( field_base.GetNDimCoord() == 2 );
	}
	m_IdFieldDisp = world.MakeField_FieldElemAry(id_field_base, id_ea,
        VECTOR2,VALUE|VELOCITY|ACCELERATION,CORNER);
	{
		m_aEqn.clear();
		const CField& field = world.GetField(m_IdFieldDisp);
		const std::vector<unsigned int>& aIdEA = field.GetAryIdEA();
		for(unsigned int iiea=0;iiea<aIdEA.size();iiea++){
			const unsigned int id_ea = aIdEA[iiea];
			assert( world.IsIdEA(id_ea) );
			const CElemAry& ea = world.GetEA(id_ea);
			if( ea.ElemType() != TRI && ea.ElemType() != QUAD ) continue;
			m_aEqn.push_back( CEqn_Solid2D(id_ea,m_IdFieldDisp) );
		}
	}
	this->ClearLinearSystemPreconditioner();
	this->m_aIdFixField.clear();
	return true;
}

unsigned int CEqn_Fluid3D::AddFixElemAry( unsigned int id_ea, Fem::Field::CFieldWorld& world, int idof)
{
    if( !world.IsIdEA( id_ea ) ) return 0;
    std::vector<unsigned int> aIdEA;
    aIdEA.push_back(id_ea);
    return this->AddFixElemAry( aIdEA, world, idof );
}

unsigned int CEqnSystem_Fluid2D::AddFixElemAry( const std::vector<unsigned int>& aIdEA, Fem::Field::CFieldWorld& world, int idof)
{
    for(unsigned int iid_ea=0; iid_ea<aIdEA.size(); iid_ea++) {
        if( !world.IsIdEA( aIdEA[iid_ea] ) ) return 0;
    }
    const unsigned int id_field = world.GetPartialField(m_id_velo, aIdEA );
    if( id_field == 0 ) return 0;
    assert( world.IsIdField(id_field) );
    //	CField& field = world.GetField(id_field);
    Fem::Field::SetFieldValue_Constant(id_field,0,Fem::Field::VELOCITY,world,0);
    Fem::Field::SetFieldValue_Constant(id_field,1,Fem::Field::VELOCITY,world,0);
    m_aIdFixField.push_back( std::make_pair(id_field,-1) );
    return id_field;
}

bool CEdgeTextureColor::Update(const Fem::Field::CFieldWorld& world)
{
	if( !world.IsIdField(this->id_field_velo) ){ return false; }
	if( !world.IsIdField(this->id_part_field_velo) ){ return false; }
	if( !world.IsIdEA(this->id_ea) ){ return false; }
	const Fem::Field::CElemAry& ea = world.GetEA(id_ea);
	assert( ea.ElemType() == Fem::Field::LINE );
	if( nelem != ea.Size() ){
		nelem  = ea.Size();
		if( m_aXYVeloElem != 0 ){ delete[] m_aXYVeloElem; }
		if( m_aXYElem     != 0 ){ delete[] m_aXYElem; }
		m_aXYVeloElem = new double [nelem*4];
		m_aXYElem     = new double [nelem*4];
	}
	const Fem::Field::CField& fv = world.GetField(this->id_part_field_velo);
//	const Fem::Field::CField::CNodeSegInNodeAry& nans = fv.GetNodeSegInNodeAry(Fem::Field::CORNER);
	const Fem::Field::CNodeAry::CNodeSeg& ns_v = fv.GetNodeSeg(CORNER,true, world,VELOCITY);
	const Fem::Field::CNodeAry::CNodeSeg& ns_c = fv.GetNodeSeg(CORNER,false,world,VELOCITY);
	const Fem::Field::CElemAry::CElemSeg& es_v = fv.GetElemSeg(id_ea,CORNER,true, world);
	const Fem::Field::CElemAry::CElemSeg& es_c = fv.GetElemSeg(id_ea,CORNER,false,world);
	assert( es_v.Length() == 2 );
	assert( es_c.Length() == 2 );
	for(unsigned int ielem=0;ielem<nelem;ielem++)
	{
		unsigned int noes[2];
		es_c.GetNodes(ielem,noes);
		double co[2][2];
		ns_c.GetValue(noes[0],co[0]);
		ns_c.GetValue(noes[1],co[1]);
		////////////////
		es_v.GetNodes(ielem,noes);
		double velo[2][2];
		ns_v.GetValue(noes[0],velo[0]);	
		ns_v.GetValue(noes[1],velo[1]);
		////////////////
		m_aXYElem[ielem*4+0] = co[0][0];
		m_aXYElem[ielem*4+1] = co[0][1];
		m_aXYElem[ielem*4+2] = co[1][0];
		m_aXYElem[ielem*4+3] = co[1][1];
		////////////////
		const double r = velo_scale;
		m_aXYVeloElem[ielem*4+0] = co[0][0] + r*velo[0][0];	
		m_aXYVeloElem[ielem*4+1] = co[0][1] + r*velo[0][1];
		m_aXYVeloElem[ielem*4+2] = co[1][0] + r*velo[1][0];
		m_aXYVeloElem[ielem*4+3] = co[1][1] + r*velo[1][1];
	}
	return true;
}

bool CDrawerImageBasedFlowVis::Set(unsigned int id_field_velo, const Fem::Field::CFieldWorld& world)
{
	if( !world.IsIdField(id_field_velo) ){ return false; }
	this->m_IdFieldVelo = id_field_velo;
	const Fem::Field::CField& fv = world.GetField(id_field_velo);
	
	////////////////////////////////
	{	// 要素配列の設定
		const std::vector<unsigned int>& aIdEA = fv.GetAryIdEA();
		for(unsigned int iiea=0;iiea<aIdEA.size();iiea++){
			const unsigned int id_ea = aIdEA[iiea];
			assert( world.IsIdEA(id_ea) );
			const unsigned int id_es_c = fv.GetIdElemSeg(id_ea,CORNER,true, world);
			assert( id_es_c != 0 );
			CIndexArrayElem* pIAE = new CIndexArrayElem(id_ea,id_es_c,world);
			pIAE->ilayer = fv.GetLayer(id_ea);
			this->m_apIndexArrayElem.push_back( pIAE );
		}
	}
	
//	if( aVelo ==0 ){ aVelo  = new double [nnode*2]; }
//	if( aCoord == 0 ){ aCoord = new double [nnode*2]; }
/*
	const std::vector<unsigned int>& aIdEA = fv.GetAryIdEA();
	unsigned int nelem0 = 0;
	for(unsigned int iiea=0;iiea<aIdEA.size();iiea++){
		const unsigned int id_ea = aIdEA[iiea];
		assert( world.IsIdEA(id_ea) );
		const Fem::Field::CElemAry& ea = world.GetEA(id_ea);
		nelem0 += ea.Size();
	}
	if( nelem != nelem0 ){
		nelem = nelem0;
		if( aXYVeloElem != 0 ){ delete[] aXYVeloElem; }
        if( aXYElem     != 0 ){ delete[] aXYElem; }
		aXYVeloElem = new double [nelem*6];
		aXYElem = new double [nelem*6];
		if( world.IsIdField(m_IdFieldColor) ){
			if( aColorElem != 0 ){ delete[] aColorElem; }
			aColorElem = new double [nelem*3];
		}
	}
	*/
	return this->Update(world);
}

bool CEqn_Scalar3D::ClearFixElemAry(
		unsigned int id_ea, Fem::Field::CFieldWorld& world)
{
	if( !world.IsIdEA( id_ea ) ) return false;
	for(unsigned int ifix=0;ifix<m_aIdFixField.size();ifix++){
		const unsigned int id_field_fix = m_aIdFixField[ifix].first;
		const Fem::Field::CField& field = world.GetField(id_field_fix);
		const std::vector<unsigned int>& aIdEA = field.GetAryIdEA();
		if( aIdEA.size() != 1 ){
			std::cout << "Error!-->Not Implimented" << std::endl;
			assert(0);
		}
		if( aIdEA[0] == id_ea ){
			m_aIdFixField.erase( m_aIdFixField.begin()+ifix );
			this->ClearLinearSystem();
		}
	}
	return true;
}

// 連立一次方程式マージメソッド
bool CEqn_Fluid2D::AddLinSys_NewmarkBetaAPrime( double dt,
        double gamma, double beta, bool is_initial,
        Fem::Ls::CLinearSystem_Field& ls, const Fem::Field::CFieldWorld& world )
{
    //    std::cout << "CEqn_Fluid2D::AddLinSys_NewmakrBetaAPrime " << m_id_ea << std::endl;
    if( !world.IsIdEA(m_id_ea) ) return false;
    if( m_IsNavierStokes ) {
        assert( !this->m_IsNavierStokesALE );
        assert( !this->m_IsStokes );
        //        std::cout << "CEqn_Fluid2D::AddLinSys_NewmarkBetaAPrime  ns " << m_id_ea << std::endl;
        return Fem::Eqn::AddLinSys_NavierStokes2D_NonStatic_Newmark(
                   dt, gamma, ls,
                   m_rho,m_myu, m_g_x,m_g_y,
                   this->m_IdFieldVelo,this->m_IdFieldPress,world,
                   m_id_ea );
    }
    else if( m_IsNavierStokesALE ) {
        assert( !this->m_IsStokes );
        assert( !this->m_IsNavierStokes );
        return Fem::Eqn::AddLinSys_NavierStokesALE2D_NonStatic_Newmark(
                   dt, gamma, ls,
                   m_rho,m_myu, m_g_x,m_g_y,
                   this->m_IdFieldVelo,this->m_IdFieldPress,this->m_IdFieldMshVelo, world );
    }
    else if( this->m_IsStokes ) {
        assert( !this->m_IsNavierStokes );
        assert( !this->m_IsNavierStokesALE );
        //        std::cout << "CEqn_Fluid2D::AddLinSys_NewmarkBetaAPrime  stokes " << m_id_ea << std::endl;
        return Fem::Eqn::AddLinSys_Stokes2D_NonStatic_Newmark(
                   m_rho,m_myu,m_g_x,m_g_y,
                   gamma,dt,
                   ls,
                   this->m_IdFieldVelo,this->m_IdFieldPress,world,
                   m_id_ea);
    }
    else {
        assert(0);
    }
    return false;
}

//.........这里部分代码省略.........
              case 1: eval.SetKey("x",coord[0]);
                break;
              default:
                assert(0);
                break;
            }
            double val = eval.Calc();
            ns_va.SetValue(inode0,idofns,val);
          }
        }
      }
    }
  }
  ////////////////////////////////
  if( field.GetNodeSegInNodeAry(BUBBLE).id_na_va != 0 ){		
    CEval eval;
    {
      eval.SetKey("x",0.0 );
      eval.SetKey("y",0.0 );
      eval.SetKey("z",0.0 );
      eval.SetKey("t",t );
      if( !eval.SetExp(math_exp) ) return false;
    }
    const CField::CNodeSegInNodeAry& nsna_b = field.GetNodeSegInNodeAry(BUBBLE);
    assert( world.IsIdNA(nsna_b.id_na_va) );
    CNodeAry& na_va = world.GetNA(nsna_b.id_na_va);	
    unsigned int id_ns;
    {
      if(      fdt & VALUE        ) id_ns = nsna_b.id_ns_va;
      else if( fdt & VELOCITY     ) id_ns = nsna_b.id_ns_ve;
      else if( fdt & ACCELERATION ) id_ns = nsna_b.id_ns_ac;
      else{ assert(0); }
    }
    assert( na_va.IsSegID(id_ns) );
    CNodeAry::CNodeSeg& ns_va = na_va.GetSeg(id_ns);
    if( !field.IsPartial() && nsna_b.id_na_co ){ // the bubble ns have coordinate and this is not partial
      std::cout << "Error!-->Not Implimented" << std::endl;
      assert(0);
      for(unsigned int inode=0;inode<na_va.Size();inode++){
        double val = eval.Calc();
        ns_va.SetValue(inode,idofns,val);
      }
    }
    else{
      assert( field.IsNodeSeg(CORNER,false,world) );
      const CNodeAry::CNodeSeg& ns_c_co = field.GetNodeSeg(CORNER,false,world);
      const unsigned int ndim = ns_c_co.Length();      
      for(unsigned int iei=0;iei<aIdEA.size();iei++){
        unsigned int id_ea = aIdEA[iei];
        assert( world.IsIdEA(id_ea) );
        CElemAry& ea = world.GetEA(id_ea);
        ////////////////
        unsigned int id_es_b_va = field.GetIdElemSeg(id_ea,BUBBLE,true,world);
        assert( ea.IsSegID(id_es_b_va) );
        const CElemAry::CElemSeg& es_b_va = ea.GetSeg(id_es_b_va);
        assert( es_b_va.Length() == 1);
        ////////////////
        const unsigned int id_es_c_co = field.GetIdElemSeg(id_ea,CORNER, false, world);
        assert( ea.IsSegID(id_es_c_co) );
        const CElemAry::CElemSeg& es_c_co = ea.GetSeg(id_es_c_co);
        const unsigned int nnoes = es_c_co.Length();
        ////////////////
        unsigned int noes_c[16];
        double coord[3], coord_cnt[3];
        unsigned int inoes_b;
        for(unsigned int ielem=0;ielem<ea.Size();ielem++){
          // calc the position of element center
          es_c_co.GetNodes(ielem,noes_c);
          es_b_va.GetNodes(ielem,&inoes_b);
          for(unsigned int idim=0;idim<ndim;idim++){ coord_cnt[idim] = 0.0; }
          for(unsigned int inoes=0;inoes<nnoes;inoes++){
            const unsigned int inode0 = noes_c[inoes];
            ns_c_co.GetValue(inode0,coord);
            for(unsigned int idim=0;idim<ndim;idim++){ coord_cnt[idim] += coord[idim]; }
          }
          for(unsigned int idim=0;idim<ndim;idim++){ coord_cnt[idim] /= nnoes; }
          ////////////////
          switch(ndim){
            case 3: eval.SetKey("z",coord_cnt[2]);
            case 2: eval.SetKey("y",coord_cnt[1]);
            case 1: eval.SetKey("x",coord_cnt[0]);
              break;
            default:
              assert(0);
              break;
          }
          double val = eval.Calc();
          ns_va.SetValue(inoes_b,idofns,val);
//          std::cout << inoes_b << " " << idofns << " " << val << std::endl;
        }
      }
    }
  }
  if( field.GetNodeSegInNodeAry(EDGE).id_na_va != 0 ){
    std::cout << "Error!-->Not Implimented" << std::endl;
    assert(0);
    getchar();
  }  
  return true;
}

bool CDrawerFace::Set
(unsigned int id_field, const Fem::Field::CFieldWorld& world, bool isnt_value_disp,
 unsigned int id_field_val)
{
	if( !world.IsIdField(id_field) ){ return false; }
	////////////////
	this->m_id_field = id_field;
	this->id_field_val = id_field_val;
	this->m_isnt_value_disp = isnt_value_disp;

	const Fem::Field::CField& field = world.GetField(id_field);

	// setting of vertex array
	unsigned int id_na_c_co = field.GetNodeSegInNodeAry(CORNER).id_na_co;
	unsigned int id_na_c_val = field.GetNodeSegInNodeAry(CORNER).id_na_va;
	////////////////////////////////
	// decide whether draw ns of value or coord
	if( id_na_c_val == 0 ){ 
		this->m_is_draw_nsv = false;	// draw NS of Coord
		this->m_isnt_value_disp = true;	// don't include displacement
	}
	else{ this->m_is_draw_nsv = true;}
	////////////////
	assert( field.IsNodeSeg(CORNER,false,world,VALUE) );
	unsigned int ndim_field = field.GetNDimCoord();
	////////////////
	unsigned int npoin;
	if( m_is_draw_nsv ){
		assert( world.IsIdNA(id_na_c_val) );
		const Fem::Field::CNodeAry& na_c_val = world.GetNA(id_na_c_val);
		npoin = na_c_val.Size();
	}
	else{ 
		assert( id_na_c_co != 0 );
		const Fem::Field::CNodeAry& na_c_co = world.GetNA(id_na_c_co);
		npoin = na_c_co.Size(); 
	}
	////////////////
  // set size to vertex array
  
	unsigned int ndim_draw;
	if( this->m_isnt_value_disp == false 
     && ndim_field == 2 
     && (field.GetFieldType()==SCALAR||field.GetFieldType()==ZSCALAR) ){
		ndim_draw = 3;
	}
	else{ ndim_draw = ndim_field; }
  this->m_vertex_ary.SetSize(npoin,ndim_draw);
  
  { // normal
    const bool is_normal = ( pNormalArray != 0 );
    if( pNormalArray != 0 ){ delete pNormalArray; pNormalArray = 0; }
    if( is_normal ){ pNormalArray = new double [npoin*3]; }
  }
  { // uv map
    const bool is_uv = ( pUVArray != 0 );
    if( pUVArray != 0 ){ delete pUVArray; pUVArray = 0; }
    if( is_uv ){ pUVArray = new double [npoin*2]; }  
  }
    
	////////////////
	if(      ndim_draw  == 2 ){ sutable_rot_mode = 1; }
	else if( ndim_field == 3 ){ sutable_rot_mode = 3; }
	else                      { sutable_rot_mode = 2; }
	CDrawerFace::Update(world);

	////////////////////////////////
	{	// setting of element array        
		const std::vector<unsigned int>& aIdEA = field.GetAryIdEA();
		for(unsigned int iiea=0;iiea<aIdEA.size();iiea++){
			const unsigned int id_ea = aIdEA[iiea];
			assert( world.IsIdEA(id_ea) );
			unsigned int id_es_c;
			if( m_is_draw_nsv ){ id_es_c = field.GetIdElemSeg(id_ea,CORNER,true, world); }
			else{                id_es_c = field.GetIdElemSeg(id_ea,CORNER,false,world); }
			assert( id_es_c != 0 );
			CIndexArrayElem* pIAE = new CIndexArrayElem(id_ea,id_es_c,world);
			pIAE->ilayer = field.GetLayer(id_ea);
			this->m_apIndexArrayElem.push_back( pIAE );
		}
	}

	////////////////////////////////
	// color setting

	if( world.IsIdField(id_field_val) ){
		const Fem::Field::CField& field_val = world.GetField(id_field_val);
		unsigned int id_na_c_val = field_val.GetNodeSegInNodeAry(CORNER).id_na_va;
		unsigned int id_na_b_val = field_val.GetNodeSegInNodeAry(BUBBLE).id_na_va;
		if(      world.IsIdNA(id_na_c_val) ){
			if( pColorArray != 0 ){ delete[] pColorArray;  pColorArray=0; }
		}
		else if( world.IsIdNA(id_na_b_val) ){
		}
	}
	this->Update(world);
	return true;
}