Nektar++
Public Member Functions | Private Attributes | List of all members
Nektar::FieldUtils::Iso Class Reference

#include <ProcessIsoContour.h>

Public Member Functions

void Condense (void)
 
void GlobalCondense (std::vector< std::shared_ptr< Iso > > &iso, bool verbose)
 
void SeparateRegions (std::vector< std::shared_ptr< Iso > > &iso, int minsize, bool verbose)
 
void Smooth (int n_iter, NekDouble lambda, NekDouble mu)
 
int GetNVert (void)
 
void SetNVert (int n)
 
int GetNTris (void)
 
void SetNTris (int n)
 
void SetFields (const int loc, const Array< OneD, Array< OneD, NekDouble > > &intfields, const int j)
 
NekDouble GetFields (const int i, const int j)
 
void SetX (int loc, NekDouble val)
 
void SetY (int loc, NekDouble val)
 
void SetZ (int loc, NekDouble val)
 
NekDouble GetX (int loc)
 
NekDouble GetY (int loc)
 
NekDouble GetZ (int loc)
 
int GetVId (int i)
 
void ResizeVId (int nconn)
 
void SetVId (int i, int j)
 
void ResizeFields (int size)
 
 Iso (int nfields)
 
 ~Iso (void)
 

Private Attributes

bool m_condensed
 
int m_nvert
 
int m_ntris
 
std::vector< NekDouble > m_x
 
std::vector< NekDouble > m_y
 
std::vector< NekDouble > m_z
 
std::vector< std::vector< NekDouble > > m_fields
 
Array< OneD, int > m_vid
 

Detailed Description

Definition at line 46 of file ProcessIsoContour.h.

Constructor & Destructor Documentation

◆ Iso()

Nektar::FieldUtils::Iso::Iso ( int  nfields)
inline

Definition at line 155 of file ProcessIsoContour.h.

156  {
157  m_condensed = false;
158  m_nvert = 0;
159  m_fields.resize(nfields);
160  // set up initial vectors to be 1000 long
161  m_x.resize(1000);
162  m_y.resize(1000);
163  m_z.resize(1000);
164  for(int i = 0; i < m_fields.size(); ++i)
165  {
166  m_fields[i].resize(1000);
167  }
168  };
Nektar::FieldUtils::Iso::m_z
std::vector< NekDouble > m_z
Definition: ProcessIsoContour.h:180
Nektar::FieldUtils::Iso::m_fields
std::vector< std::vector< NekDouble > > m_fields
Definition: ProcessIsoContour.h:181
Nektar::FieldUtils::Iso::m_y
std::vector< NekDouble > m_y
Definition: ProcessIsoContour.h:179
Nektar::FieldUtils::Iso::m_x
std::vector< NekDouble > m_x
Definition: ProcessIsoContour.h:178

References m_condensed, m_fields, m_nvert, m_x, m_y, and m_z.

◆ ~Iso()

Nektar::FieldUtils::Iso::~Iso ( void  )
inline

Definition at line 170 of file ProcessIsoContour.h.

171  {
172  }

Member Function Documentation

◆ Condense()

void Nektar::FieldUtils::Iso::Condense ( void  )

Definition at line 672 of file ProcessIsoContour.cpp.

673 {
674  int i,j,cnt;
675  IsoVertex v;
676  vector<IsoVertex> vert;
677 
678  if(!m_ntris) return;
679 
680  if(m_condensed) return;
681  m_condensed = true;
682 
683  vert.reserve(m_ntris/6);
684 
685  m_vid = Array<OneD, int>(3*m_ntris);
686 
687  // fill first 3 points and initialise fields
688  v.m_fields.resize(m_fields.size());
689  for(cnt =0, i = 0; i < 3; ++i)
690  {
691  v.m_x = m_x[i];
692  v.m_y = m_y[i];
693  v.m_z = m_z[i];
694  for(int f = 0; f < m_fields.size(); ++f)
695  {
696  v.m_fields[f] = m_fields[f][i];
697  }
698  v.m_id = cnt;
699  vert.push_back(v);
700  m_vid[i] = v.m_id;
701  ++cnt;
702  }
703 
704  for(i = 1; i < m_ntris; ++i)
705  {
706  for(j = 0; j < 3; ++j)
707  {
708  v.m_x = m_x[3*i+j];
709  v.m_y = m_y[3*i+j];
710  v.m_z = m_z[3*i+j];
711 
712  auto pt = find(vert.begin(),vert.end(),v);
713  if(pt != vert.end())
714  {
715  m_vid[3*i+j] = pt[0].m_id;
716  }
717  else
718  {
719  v.m_id = cnt;
720 
721  for(int f = 0; f < m_fields.size(); ++f)
722  {
723  v.m_fields[f] = m_fields[f][3*i+j];
724  }
725 
726  vert.push_back(v);
727 
728  m_vid[3*i+j] = v.m_id;
729  ++cnt;
730  }
731  }
732  }
733 
734  // remove elements with multiple vertices
735  for(i = 0,cnt=0; i < m_ntris;)
736  {
737  if((m_vid[3*i] ==m_vid[3*i+1])||
738  (m_vid[3*i] ==m_vid[3*i+2])||
739  (m_vid[3*i+1]==m_vid[3*i+2]))
740  {
741  cnt++;
742  for(j = 3*i; j < 3*(m_ntris-1); ++j)
743  {
744  m_vid[j] = m_vid[j+3];
745  }
746  m_ntris--;
747  }
748  else
749  {
750  ++i;
751  }
752  }
753 
754  m_nvert = vert.size();
755 
756  m_x.resize(m_nvert);
757  m_y.resize(m_nvert);
758  m_z.resize(m_nvert);
759 
760  for(int f = 0; f < m_fields.size(); ++f)
761  {
762  m_fields[f].resize(m_nvert);
763  }
764 
765  for(i = 0; i < m_nvert; ++i)
766  {
767  m_x[i] = vert[i].m_x;
768  m_y[i] = vert[i].m_y;
769  m_z[i] = vert[i].m_z;
770  for(int f = 0; f < m_fields.size(); ++f)
771  {
772  m_fields[f][i] = vert[i].m_fields[f];
773  }
774  }
775 }
Nektar::FieldUtils::Iso::m_vid
Array< OneD, int > m_vid
Definition: ProcessIsoContour.h:182
Nektar::StdRegions::find
InputIterator find(InputIterator first, InputIterator last, InputIterator startingpoint, const EqualityComparable &value)
Definition: StdRegions.hpp:362

References Nektar::StdRegions::find(), m_condensed, m_fields, Nektar::FieldUtils::IsoVertex::m_fields, Nektar::FieldUtils::IsoVertex::m_id, m_ntris, m_nvert, m_vid, m_x, Nektar::FieldUtils::IsoVertex::m_x, m_y, Nektar::FieldUtils::IsoVertex::m_y, m_z, and Nektar::FieldUtils::IsoVertex::m_z.

◆ GetFields()

NekDouble Nektar::FieldUtils::Iso::GetFields ( const int  i,
const int  j 
)
inline

Definition at line 89 of file ProcessIsoContour.h.

90  {
91  return m_fields[i][j];
92  }

References m_fields.

◆ GetNTris()

int Nektar::FieldUtils::Iso::GetNTris ( void  )
inline

Definition at line 65 of file ProcessIsoContour.h.

66  {
67  return m_ntris;
68  }

References m_ntris.

◆ GetNVert()

int Nektar::FieldUtils::Iso::GetNVert ( void  )
inline

Definition at line 55 of file ProcessIsoContour.h.

56  {
57  return m_nvert;
58  }

References m_nvert.

◆ GetVId()

int Nektar::FieldUtils::Iso::GetVId ( int  i)
inline

Definition at line 124 of file ProcessIsoContour.h.

125  {
126  return m_vid[i];
127  }

References m_vid.

◆ GetX()

NekDouble Nektar::FieldUtils::Iso::GetX ( int  loc)
inline

Definition at line 109 of file ProcessIsoContour.h.

110  {
111  return m_x[loc];
112  }
CG_Iterations.loc
loc
Definition: CG_Iterations.py:323

References CG_Iterations::loc, and m_x.

◆ GetY()

NekDouble Nektar::FieldUtils::Iso::GetY ( int  loc)
inline

Definition at line 114 of file ProcessIsoContour.h.

115  {
116  return m_y[loc];
117  }

References CG_Iterations::loc, and m_y.

◆ GetZ()

NekDouble Nektar::FieldUtils::Iso::GetZ ( int  loc)
inline

Definition at line 119 of file ProcessIsoContour.h.

120  {
121  return m_z[loc];
122  }

References CG_Iterations::loc, and m_z.

◆ GlobalCondense()

void Nektar::FieldUtils::Iso::GlobalCondense ( std::vector< std::shared_ptr< Iso > > &  iso,
bool  verbose 
)

Definition at line 778 of file ProcessIsoContour.cpp.

779 {
780  typedef bg::model::point<NekDouble, 3, bg::cs::cartesian> BPoint;
781  typedef std::pair<BPoint, unsigned int> PointPair;
782 
783  int i,j,n;
784  int nelmt;
785  int niso=iso.size();
786  int id1,id2;
787  Array<OneD, Array<OneD, int> > vidmap;
788 
789  if(m_condensed) return;
790  m_condensed = true;
791 
792  vidmap = Array<OneD, Array<OneD, int> > (niso);
793 
794  m_ntris = 0;
795  for(i = 0; i < niso; ++i)
796  {
797  if(iso[i]->m_ntris)
798  {
799  m_ntris += iso[i]->m_ntris;
800  }
801  }
802 
803  m_vid = Array<OneD, int>(3*m_ntris);
804 
805  m_nvert = 0;
806  for(i = 0; i < niso; ++i)
807  {
808  if(iso[i]->m_ntris)
809  {
810  m_nvert += iso[i]->m_nvert;
811  }
812  }
813 
814  vector< vector<int> > isocon;
815  isocon.resize(niso);
816  vector<int> global_to_unique_map;
817  global_to_unique_map.resize(m_nvert);
818 
819  vector< pair<int,int> > global_to_iso_map;
820  global_to_iso_map.resize(m_nvert);
821 
822  //Fill vertex array into rtree format
823  id2 = 0;
824  std::vector<PointPair> inPoints;
825  for(i = 0; i < niso; ++i)
826  {
827  for(id1 = 0; id1 < iso[i]->m_nvert; ++id1)
828  {
829  inPoints.push_back(PointPair(BPoint( iso[i]->m_x[id1],
830  iso[i]->m_y[id1],
831  iso[i]->m_z[id1]), id2));
832  global_to_unique_map[id2]=id2;
833  global_to_iso_map[id2] = make_pair(i,id1);
834  id2++;
835  }
836  }
837 
838 
839  if(verbose)
840  {
841  cout << "\t Process building tree ..." << endl;
842  }
843 
844  //Build tree
845  bgi::rtree<PointPair, bgi::rstar<16> > rtree;
846  rtree.insert(inPoints.begin(), inPoints.end());
847 
848  //Find neighbours
849  int unique_index = 0;
850  int prog=0;
851  for(i = 0; i < m_nvert; ++i)
852  {
853  if(verbose)
854  {
855  prog = LibUtilities::PrintProgressbar(i,m_nvert,
856  "Nearest verts",prog);
857  }
858 
859  BPoint queryPoint = inPoints[i].first;
860 
861 
862  // check to see if point has been already reset to lower than
863  // unique value
864  if(global_to_unique_map[i] < unique_index) // do nothing
865  {
866  }
867  else
868  {
869  // find nearest 10 points within the distance box
870  std::vector<PointPair> result;
871  rtree.query(bgi::nearest(queryPoint, 10), std::back_inserter(result));
872 
873  //see if any values have unique value already
874  set<int> samept;
875  int new_index = -1;
876  for(id1 = 0; id1 < result.size(); ++id1)
877  {
878  NekDouble dist = bg::distance(queryPoint, result[id1].first);
879  if(dist*dist < NekConstants::kNekZeroTol) // same point
880  {
881  id2 = result[id1].second;
882  samept.insert(id2);
883 
884  if(global_to_unique_map[id2] <unique_index)
885  {
886  new_index = global_to_unique_map[id2];
887  }
888  }
889  }
890  if(new_index == -1)
891  {
892  new_index = unique_index;
893  unique_index++;
894  }
895 
896  // reset all same values to new_index
897  global_to_unique_map[i] = new_index;
898  for(auto &it : samept)
899  {
900  global_to_unique_map[it] = new_index;
901  }
902  }
903  }
904 
905  if(verbose)
906  {
907  cout << endl;
908  }
909 
910  m_nvert = unique_index;
911 
912  nelmt = 0;
913  // reset m_vid;
914  int cnt = 0;
915  for(n = 0; n < niso; ++n)
916  {
917  for(i = 0; i < iso[n]->m_ntris; ++i,nelmt++)
918  {
919  for(j=0; j < 3;++j)
920  {
921  m_vid[3*nelmt+j] = global_to_unique_map[iso[n]->m_vid[3*i+j]+cnt];
922  }
923  }
924  cnt += iso[n]->m_nvert;
925  }
926 
927  m_ntris = nelmt;
928 
929  m_x.resize(m_nvert);
930  m_y.resize(m_nvert);
931  m_z.resize(m_nvert);
932 
933  m_fields.resize(iso[0]->m_fields.size());
934  for(i = 0; i < iso[0]->m_fields.size(); ++i)
935  {
936  m_fields[i].resize(m_nvert);
937  }
938 
939  for(n = 0; n < global_to_unique_map.size(); ++n)
940  {
941 
942  m_x[global_to_unique_map[n]] = bg::get<0>(inPoints[n].first);
943  m_y[global_to_unique_map[n]] = bg::get<1>(inPoints[n].first);
944  m_z[global_to_unique_map[n]] = bg::get<2>(inPoints[n].first);
945 
946  int isoid = global_to_iso_map[n].first;
947  int ptid = global_to_iso_map[n].second;
948  for(j = 0; j < m_fields.size(); ++j)
949  {
950  m_fields[j][global_to_unique_map[n]] = iso[isoid]->
951  m_fields[j][ptid];
952  }
953  }
954 }
Nektar::LibUtilities::PrintProgressbar
int PrintProgressbar(const int position, const int goal, const std::string message, int lastprogress=-1)
Prints a progressbar.
Definition: Progressbar.hpp:67
Nektar::NekConstants::kNekZeroTol
static const NekDouble kNekZeroTol
Definition: NektarUnivConsts.hpp:51
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43

References Nektar::NekConstants::kNekZeroTol, m_condensed, m_fields, m_ntris, m_nvert, m_vid, m_x, m_y, m_z, and Nektar::LibUtilities::PrintProgressbar().

◆ ResizeFields()

void Nektar::FieldUtils::Iso::ResizeFields ( int  size)
inline

Definition at line 139 of file ProcessIsoContour.h.

140  {
141  if(size > m_x.size()) // add 1000 element to vectors
142  {
143  m_x.resize(size+100);
144  m_y.resize(size+100);
145  m_z.resize(size+100);;
146  for(int i = 0; i < m_fields.size(); ++i)
147  {
148  m_fields[i].resize(size+1000);
149  }
150 
151  }
152  m_nvert = size;
153  }

References m_fields, m_nvert, m_x, m_y, and m_z.

◆ ResizeVId()

void Nektar::FieldUtils::Iso::ResizeVId ( int  nconn)
inline

Definition at line 129 of file ProcessIsoContour.h.

130  {
131  m_vid = Array<OneD, int>(nconn);
132  }

References m_vid.

◆ SeparateRegions()

void Nektar::FieldUtils::Iso::SeparateRegions ( std::vector< std::shared_ptr< Iso > > &  iso,
int  minsize,
bool  verbose 
)

Definition at line 1075 of file ProcessIsoContour.cpp.

1076 {
1077  int i,j,k,id;
1078  Array<OneD, vector<int> >vertcon(m_nvert);
1079  list<int> tocheck;
1080 
1081  Array<OneD, bool> viddone(m_nvert,false);
1082 
1083  // make list of connecting tris around each vertex
1084  for(i = 0; i < m_ntris; ++i)
1085  {
1086  for(j = 0; j < 3; ++j)
1087  {
1088  vertcon[m_vid[3*i+j]].push_back(i);
1089  }
1090  }
1091 
1092  Array<OneD, int> vidregion(m_nvert,-1);
1093 
1094  int nregions = -1;
1095 
1096 
1097  // check all points are assigned to a region
1098  int progcnt = -1;
1099  for(k = 0; k < m_nvert; ++k)
1100  {
1101  if(verbose)
1102  {
1103  progcnt = LibUtilities::PrintProgressbar(k,m_nvert,"Separating regions",progcnt);
1104  }
1105 
1106  if(vidregion[k] == -1)
1107  {
1108  vidregion[k] = ++nregions;
1109 
1110  // find all elmts around this.. vertex that need to be checked
1111  for(auto &ipt : vertcon[k])
1112  {
1113  for(i = 0; i < 3; ++i)
1114  {
1115  if(vidregion[id = m_vid[3*ipt+i]] == -1)
1116  {
1117  tocheck.push_back(id);
1118  vidregion[id] = nregions;
1119  }
1120  }
1121  }
1122  viddone[k] = 1;
1123 
1124  // check all other neighbouring vertices
1125  while(tocheck.size())
1126  {
1127  auto cid = tocheck.begin();
1128  while(cid != tocheck.end())
1129  {
1130  if(!viddone[*cid])
1131  {
1132  for(auto &ipt : vertcon[*cid])
1133  {
1134  for(i = 0; i < 3; ++i)
1135  {
1136  if(vidregion[id = m_vid[3*ipt+i]] == -1)
1137  {
1138  tocheck.push_back(id);
1139  vidregion[id] = nregions;
1140  }
1141  }
1142  }
1143  viddone[*cid] = 1;
1144  ++cid;
1145  tocheck.pop_front();
1146  }
1147  }
1148  }
1149  }
1150  }
1151  nregions++;
1152 
1153 
1154  Array<OneD, int> nvert(nregions,0);
1155  Array<OneD, int> nelmt(nregions,0);
1156 
1157  // count nverts
1158  for(i = 0; i < m_nvert; ++i)
1159  {
1160  nvert[vidregion[i]] +=1;
1161  }
1162 
1163  // count nelmts
1164  for(i = 0; i < m_ntris; ++i)
1165  {
1166  nelmt[vidregion[m_vid[3*i]]] +=1;
1167  }
1168 
1169  Array<OneD, int> vidmap(m_nvert);
1170  // generate new list of isocontour
1171  for(int n = 0; n < nregions; ++n)
1172  {
1173  if(nelmt[n] > minsize)
1174  {
1175  int nfields = m_fields.size();
1176  IsoSharedPtr iso = MemoryManager<Iso>::AllocateSharedPtr(nfields);
1177 
1178  iso->m_ntris = nelmt[n];
1179  iso->m_vid = Array<OneD, int>(3*nelmt[n]);
1180 
1181  iso->m_nvert = nvert[n];
1182  iso->m_x.resize(nvert[n]);
1183  iso->m_y.resize(nvert[n]);
1184  iso->m_z.resize(nvert[n]);
1185 
1186  iso->m_fields.resize(nfields);
1187  for(i = 0; i < nfields; ++i)
1188  {
1189  iso->m_fields[i].resize(nvert[n]);
1190  }
1191 
1192 
1193  int cnt = 0;
1194  // generate vid map;
1195  Vmath::Zero(m_nvert,vidmap,1);
1196  for(i = 0; i < m_nvert; ++i)
1197  {
1198  if(vidregion[i] == n)
1199  {
1200  vidmap[i] = cnt++;
1201  }
1202  }
1203 
1204  cnt = 0;
1205  for(i = 0; i < m_ntris; ++i)
1206  {
1207  if(vidregion[m_vid[3*i]] == n)
1208  {
1209  for(j = 0; j < 3; ++j)
1210  {
1211  iso->m_vid[3*cnt+j] = vidmap[m_vid[3*i+j]];
1212 
1213  iso->m_x[vidmap[m_vid[3*i+j]]] = m_x[m_vid[3*i+j]];
1214  iso->m_y[vidmap[m_vid[3*i+j]]] = m_y[m_vid[3*i+j]];
1215  iso->m_z[vidmap[m_vid[3*i+j]]] = m_z[m_vid[3*i+j]];
1216 
1217  for(k = 0; k < nfields; ++k)
1218  {
1219  iso->m_fields[k][vidmap[m_vid[3*i+j]]] = m_fields[k][m_vid[3*i+j]];
1220  }
1221  }
1222  cnt++;
1223  }
1224  }
1225 
1226  WARNINGL0(cnt == nelmt[n],"Number of elements do not match");
1227  sep_iso.push_back(iso);
1228  }
1229  }
1230 }
WARNINGL0
#define WARNINGL0(condition, msg)
Definition: ErrorUtil.hpp:223
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:171
Nektar::FieldUtils::IsoSharedPtr
std::shared_ptr< Iso > IsoSharedPtr
Definition: ProcessIsoContour.h:186
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:436

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), m_fields, m_ntris, m_nvert, m_vid, m_x, m_y, m_z, Nektar::LibUtilities::PrintProgressbar(), WARNINGL0, and Vmath::Zero().

◆ SetFields()

void Nektar::FieldUtils::Iso::SetFields ( const int  loc,
const Array< OneD, Array< OneD, NekDouble > > &  intfields,
const int  j 
)
inline

Definition at line 75 of file ProcessIsoContour.h.

78  {
79  m_x[loc] = intfields[0][j];
80  m_y[loc] = intfields[1][j];
81  m_z[loc] = intfields[2][j];
82 
83  for(int i = 0; i < intfields.size()-3; ++i)
84  {
85  m_fields[i][loc] = intfields[i+3][j];
86  }
87  }

References CG_Iterations::loc, m_fields, m_x, m_y, and m_z.

◆ SetNTris()

void Nektar::FieldUtils::Iso::SetNTris ( int  n)
inline

Definition at line 70 of file ProcessIsoContour.h.

71  {
72  m_ntris = n;
73  }

References m_ntris.

◆ SetNVert()

void Nektar::FieldUtils::Iso::SetNVert ( int  n)
inline

Definition at line 60 of file ProcessIsoContour.h.

61  {
62  m_nvert = n;
63  }

References m_nvert.

◆ SetVId()

void Nektar::FieldUtils::Iso::SetVId ( int  i,
int  j 
)
inline

Definition at line 134 of file ProcessIsoContour.h.

135  {
136  m_vid[i] = j;
137  }

References m_vid.

◆ SetX()

void Nektar::FieldUtils::Iso::SetX ( int  loc,
NekDouble  val 
)
inline

Definition at line 94 of file ProcessIsoContour.h.

95  {
96  m_x[loc] = val;
97  }

References CG_Iterations::loc, and m_x.

◆ SetY()

void Nektar::FieldUtils::Iso::SetY ( int  loc,
NekDouble  val 
)
inline

Definition at line 99 of file ProcessIsoContour.h.

100  {
101  m_y[loc] = val;
102  }

References CG_Iterations::loc, and m_y.

◆ SetZ()

void Nektar::FieldUtils::Iso::SetZ ( int  loc,
NekDouble  val 
)
inline

Definition at line 104 of file ProcessIsoContour.h.

105  {
106  m_z[loc] = val;
107  }

References CG_Iterations::loc, and m_z.

◆ Smooth()

void Nektar::FieldUtils::Iso::Smooth ( int  n_iter,
NekDouble  lambda,
NekDouble  mu 
)

Definition at line 971 of file ProcessIsoContour.cpp.

972 {
973  int iter,i,j,k;
974  NekDouble del_v[3];
975  NekDouble w;
976  Array<OneD, NekDouble> xtemp, ytemp, ztemp;
977  vector< vector<int> > adj,vertcon;
978  vector< vector<NekDouble > > wght;
979 
980  // determine elements around each vertex
981  vertcon.resize(m_nvert);
982  for(i = 0; i < m_ntris; ++i)
983  {
984  for(j = 0; j < 3; ++j)
985  {
986  vertcon[m_vid[3*i+j]].push_back(i);
987  }
988  }
989 
990  // determine vertices and weights around each vertex
991  adj.resize(m_nvert);
992  wght.resize(m_nvert);
993 
994  for(i =0; i < m_nvert; ++i)
995  {
996  // loop over surrounding elements
997  for(auto &ipt : vertcon[i])
998  {
999  for(j = 0; j < 3; ++j)
1000  {
1001  // make sure not adding own vertex
1002  if(m_vid[3*ipt+j] != i)
1003  {
1004  // check to see if vertex has already been added
1005  for(k = 0; k < adj[i].size(); ++k)
1006  {
1007  if(adj[i][k] == m_vid[3*ipt+j])
1008  {
1009  break;
1010  }
1011  }
1012 
1013  if(k == adj[i].size())
1014  {
1015  adj[i].push_back(m_vid[3*ipt+j]);
1016  }
1017  }
1018  }
1019  }
1020  }
1021 
1022  // Currently set weights up as even distribution
1023  for(i =0; i < m_nvert; ++i)
1024  {
1025  w = 1.0/((NekDouble)adj[i].size());
1026  for(j = 0; j < adj[i].size(); ++j)
1027  {
1028  wght[i].push_back(w);
1029  }
1030  }
1031 
1032 
1033  xtemp = Array<OneD, NekDouble>(m_nvert);
1034  ytemp = Array<OneD, NekDouble>(m_nvert);
1035  ztemp = Array<OneD, NekDouble>(m_nvert);
1036 
1037  // smooth each point
1038  for (iter=0;iter<n_iter;iter++)
1039  {
1040  // compute first weighted average
1041  for(i=0;i< m_nvert;++i)
1042  {
1043  del_v[0] = del_v[1] = del_v[2] = 0.0;
1044  for(j = 0; j < adj[i].size(); ++j)
1045  {
1046  del_v[0] = del_v[0] + (m_x[adj[i][j]]-m_x[i])*wght[i][j];
1047  del_v[1] = del_v[1] + (m_y[adj[i][j]]-m_y[i])*wght[i][j];
1048  del_v[2] = del_v[2] + (m_z[adj[i][j]]-m_z[i])*wght[i][j];
1049  }
1050 
1051  xtemp[i] = m_x[i] + del_v[0] * lambda;
1052  ytemp[i] = m_y[i] + del_v[1] * lambda;
1053  ztemp[i] = m_z[i] + del_v[2] * lambda;
1054  }
1055 
1056  // compute second weighted average
1057  for(i=0;i< m_nvert;++i)
1058  {
1059  del_v[0] = del_v[1] = del_v[2] = 0;
1060  for(j = 0; j < adj[i].size(); ++j)
1061  {
1062  del_v[0] = del_v[0] + (xtemp[adj[i][j]]-xtemp[i])*wght[i][j];
1063  del_v[1] = del_v[1] + (ytemp[adj[i][j]]-ytemp[i])*wght[i][j];
1064  del_v[2] = del_v[2] + (ztemp[adj[i][j]]-ztemp[i])*wght[i][j];
1065  }
1066 
1067  m_x[i] = xtemp[i] + del_v[0] * mu;
1068  m_y[i] = ytemp[i] + del_v[1] * mu;
1069  m_z[i] = ztemp[i] + del_v[2] * mu;
1070  }
1071  }
1072 }

References m_ntris, m_nvert, m_vid, m_x, m_y, and m_z.

Member Data Documentation

◆ m_condensed

bool Nektar::FieldUtils::Iso::m_condensed
private

Definition at line 175 of file ProcessIsoContour.h.

Referenced by Condense(), GlobalCondense(), and Iso().

◆ m_fields

std::vector<std::vector<NekDouble> > Nektar::FieldUtils::Iso::m_fields
private

Definition at line 181 of file ProcessIsoContour.h.

Referenced by Condense(), GetFields(), GlobalCondense(), Iso(), ResizeFields(), SeparateRegions(), and SetFields().

◆ m_ntris

int Nektar::FieldUtils::Iso::m_ntris
private

Definition at line 177 of file ProcessIsoContour.h.

Referenced by Condense(), GetNTris(), GlobalCondense(), SeparateRegions(), SetNTris(), and Smooth().

◆ m_nvert

int Nektar::FieldUtils::Iso::m_nvert
private

Definition at line 176 of file ProcessIsoContour.h.

Referenced by Condense(), GetNVert(), GlobalCondense(), Iso(), ResizeFields(), SeparateRegions(), SetNVert(), and Smooth().

◆ m_vid

Array<OneD, int> Nektar::FieldUtils::Iso::m_vid
private

Definition at line 182 of file ProcessIsoContour.h.

Referenced by Condense(), GetVId(), GlobalCondense(), ResizeVId(), SeparateRegions(), SetVId(), and Smooth().

◆ m_x

std::vector<NekDouble> Nektar::FieldUtils::Iso::m_x
private

Definition at line 178 of file ProcessIsoContour.h.

Referenced by Condense(), GetX(), GlobalCondense(), Iso(), ResizeFields(), SeparateRegions(), SetFields(), SetX(), and Smooth().

◆ m_y

std::vector<NekDouble> Nektar::FieldUtils::Iso::m_y
private

Definition at line 179 of file ProcessIsoContour.h.

Referenced by Condense(), GetY(), GlobalCondense(), Iso(), ResizeFields(), SeparateRegions(), SetFields(), SetY(), and Smooth().

◆ m_z

std::vector<NekDouble> Nektar::FieldUtils::Iso::m_z
private

Definition at line 180 of file ProcessIsoContour.h.

Referenced by Condense(), GetZ(), GlobalCondense(), Iso(), ResizeFields(), SeparateRegions(), SetFields(), SetZ(), and Smooth().

Generated on Wed Nov 24 2021 10:33:33 for Nektar++ by doxygen 1.9.1