Vertices Class Reference

Declaration of Vertices class. More...

#include <Vertices.h>

Inheritance diagram for Vertices:

Public Member Functions
	Vertices ()
	~Vertices ()
Vertices *	Copy ()
void	Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
void	Finalize (IoModel *iomodel)
int	NumberOfVertices (void)
int	NumberOfVerticesLocal (void)
int	NumberOfVerticesLocalAll (void)
void	LatLonList (IssmDouble **lat, IssmDouble **lon)
Public Member Functions inherited from DataSet
	DataSet ()
	DataSet (int enum_type)
	~DataSet ()
void	Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
int	GetEnum ()
int	GetEnum (int offset)
void	Echo ()
void	DeepEcho ()
int	AddObject (Object *object)
int	DeleteObject (int id)
int	Size ()
void	clear ()
Object *	GetObjectByOffset (int offset)
Object *	GetObjectById (int *poffset, int eid)
void	Presort ()
void	Sort ()
DataSet *	Copy (void)
int	DeleteObject (Object *object)

Data Fields
int *	common_recv
int **	common_recv_ids
int *	common_send
int **	common_send_ids
Data Fields inherited from DataSet
std::vector< Object * >	objects
int	enum_type
int	sorted
int	presorted
int	numsorted
int *	sorted_ids
int *	id_offsets

Private Attributes
int	numberofvertices
int	numberofvertices_local
int	numberofmasters_local

Detailed Description

Declaration of Vertices class.

Declaration of Vertices class. Vertices are vector lists (Containers) of Vertex objects. A vertex is a set of (x,y,z) coordinates defining the location of points in the mesh (not to be confused with a node, which is a degree of freedom (DOF) for a particular analysis).

Definition at line 15 of file Vertices.h.

Constructor & Destructor Documentation

Vertices()

Vertices::Vertices

(

)

Definition at line 26 of file Vertices.cpp.

                  {/*{{{*/
   this->enum_type              = VerticesEnum;
   this->common_recv            = NULL;
   this->common_recv_ids        = NULL;
   this->common_send            = NULL;
   this->common_send_ids        = NULL;
   this->numberofvertices       = -1;
   this->numberofvertices_local = -1;
   this->numberofmasters_local  = -1;
   return;
}

~Vertices()

Vertices::~Vertices

(

)

Definition at line 38 of file Vertices.cpp.

                   {/*{{{*/
 
   int num_proc=IssmComm::GetSize();
 
   if(this->common_recv) xDelete<int>(common_recv);
   if(this->common_send) xDelete<int>(common_send);
   if(this->common_recv_ids){
      for(int i=0;i<num_proc;i++) if(common_recv_ids[i]) xDelete<int>(common_recv_ids[i]);
      xDelete<int*>(common_recv_ids);
   }
   if(this->common_send_ids){
      for(int i=0;i<num_proc;i++) if(common_send_ids[i]) xDelete<int>(common_send_ids[i]);
      xDelete<int*>(common_send_ids);
   }
   return;
}

Member Function Documentation

Copy()

Vertices * Vertices::Copy

(

void

)

Definition at line 57 of file Vertices.cpp.

                         {/*{{{*/
 
   int num_proc = IssmComm::GetSize();
 
   /*Copy dataset*/
   Vertices* output=new Vertices();
   output->sorted    = this->sorted;
   output->numsorted = this->numsorted;
   output->presorted = this->presorted;
   for(vector<Object*>::iterator obj=this->objects.begin() ; obj < this->objects.end(); obj++ ) output->AddObject((*obj)->copy());
 
   /*Build id_offsets and sorted_ids*/
   output->id_offsets=NULL;
   output->sorted_ids=NULL;
   int objsize = this->numsorted;
   if(this->sorted && objsize>0 && this->id_offsets){ 
      output->id_offsets=xNew<int>(objsize);
      xMemCpy<int>(output->id_offsets,this->id_offsets,objsize);
   }
   if(this->sorted && objsize>0 && this->sorted_ids){
      output->sorted_ids=xNew<int>(objsize);
      xMemCpy<int>(output->sorted_ids,this->sorted_ids,objsize);
   }
 
   /*Copy other fields*/
   output->numberofvertices       = this->numberofvertices;
   output->numberofvertices_local = this->numberofvertices_local;
   output->numberofmasters_local  = this->numberofmasters_local;
 
   if(this->common_recv){
      output->common_recv=xNew<int>(num_proc);
      for(int i=0;i<num_proc;i++) output->common_recv[i]=this->common_recv[i];
   }
   if(this->common_send){
      output->common_send=xNew<int>(num_proc);
      for(int i=0;i<num_proc;i++) output->common_send[i]=this->common_send[i];
   }
   if(this->common_recv_ids){
      output->common_recv_ids = xNew<int*>(num_proc);
      for(int i=0;i<num_proc;i++){
         output->common_recv_ids[i]=xNew<int>(this->common_recv[i]);
         for(int j=0;j<this->common_recv[i];j++) output->common_recv_ids[i][j]=this->common_recv_ids[i][j];
      }
   }
   if(this->common_send_ids){
      output->common_send_ids = xNew<int*>(num_proc);
      for(int i=0;i<num_proc;i++){
         output->common_send_ids[i]=xNew<int>(this->common_send[i]);
         for(int j=0;j<this->common_send[i];j++) output->common_send_ids[i][j]=this->common_send_ids[i][j];
      }
   }
 
   return output;
}

Marshall()

void Vertices::Marshall	(	char **	pmarshalled_data,
		int *	pmarshalled_data_size,
		int	marshall_direction
	)

Definition at line 112 of file Vertices.cpp.

                                                                                                 { /*{{{*/
 
   int num_procs=IssmComm::GetSize();
   int test = num_procs;
   MARSHALLING_ENUM(VerticesEnum);
   MARSHALLING(numberofvertices);
   MARSHALLING(numberofvertices_local);
   MARSHALLING(numberofmasters_local);
   MARSHALLING(test);
   if(test!=num_procs) _error_("number of cores is not the same as before");
   MARSHALLING_DYNAMIC(this->common_recv,int,num_procs);
   MARSHALLING_DYNAMIC(this->common_send,int,num_procs);
   if(marshall_direction == MARSHALLING_BACKWARD){
      this->common_recv_ids = xNew<int*>(num_procs);
      this->common_send_ids = xNew<int*>(num_procs);
   }
   for(int i=0;i<num_procs;i++){
      MARSHALLING_DYNAMIC(this->common_recv_ids[i],int,this->common_recv[i]);
      MARSHALLING_DYNAMIC(this->common_send_ids[i],int,this->common_send[i]);
   }
   DataSet::Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
}

Finalize()

void Vertices::Finalize

(

IoModel *

iomodel

)

Definition at line 173 of file Vertices.cpp.

                                       {/*{{{*/
 
   /*Here we do 3 things:
    * - count all vertices once for all so that we do not need to call MPI
    *   every time we need to know the total number of vertices
    * - Distribute lids (local ids): masters first, slaves second
    * - Distribute pids (parallel ids)
    *   */
 
   /*recover my_rank:*/
   ISSM_MPI_Status status;
   int my_rank   = IssmComm::GetRank();
   int num_procs = IssmComm::GetSize();
 
   /*1. set number of vertices once for all*/
   this->numberofvertices_local=this->Size();
   this->numberofmasters_local=0;
   for(int i=0;i<this->Size();i++){
      Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
      if(!vertex->clone) this->numberofmasters_local++;
   }
   ISSM_MPI_Allreduce((void*)&this->numberofmasters_local,(void*)&this->numberofvertices,1,ISSM_MPI_INT,ISSM_MPI_SUM,IssmComm::GetComm());
 
   /*2. Distribute lids (First: masters, then clones)*/
   iomodel->my_vertices_lids=xNew<int>(this->numberofvertices);
   for(int i=0;i<this->numberofvertices;i++) iomodel->my_vertices_lids[i] = -1;
 
   int lid = 0;
   for(int i=0;i<this->Size();i++){
      Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
      if(!vertex->clone){
         vertex->lid=lid;
         iomodel->my_vertices_lids[vertex->sid] = lid;
         lid++;
      }
   }
   for(int i=0;i<this->Size();i++){
      Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
      if(vertex->clone){
         vertex->lid=lid;
         iomodel->my_vertices_lids[vertex->sid] = lid;
         lid++;
      }
   }
 
   /*3. Distribute pids based on lids and offsets*/
   int* all_num_masters=xNew<int>(num_procs);
   ISSM_MPI_Gather(&this->numberofmasters_local,1,ISSM_MPI_INT,all_num_masters,1,ISSM_MPI_INT,0,IssmComm::GetComm());
   ISSM_MPI_Bcast(all_num_masters,num_procs,ISSM_MPI_INT,0,IssmComm::GetComm());
   int offset=0;
   for(int i=0;i<my_rank;i++) offset+=all_num_masters[i];
   xDelete<int>(all_num_masters);
 
   for(int i=0;i<this->Size();i++){
      Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
      vertex->pid = vertex->lid+offset;
   }
 
   /* Share pids of masters and update pids of clones*/
   int* truepids = xNew<int>(this->Size()); //only one alloc
   for(int rank=0;rank<num_procs;rank++){
      if(this->common_send[rank]){
         int  numids = this->common_send[rank];
         for(int i=0;i<numids;i++){
            Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(this->common_send_ids[rank][i]));
            truepids[i] = vertex->pid;
         }
         ISSM_MPI_Send(truepids,numids,ISSM_MPI_INT,rank,0,IssmComm::GetComm());
      }
   }
   for(int rank=0;rank<num_procs;rank++){
      if(this->common_recv[rank]){
         int  numids = this->common_recv[rank];
         ISSM_MPI_Recv(truepids,numids,ISSM_MPI_INT,rank,0,IssmComm::GetComm(),&status);
         for(int i=0;i<numids;i++){
            Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(this->common_recv_ids[rank][i]));
            vertex->pid = truepids[i];
         }
      }
   }
   xDelete<int>(truepids);
}/*}}}*/

NumberOfVertices()

int Vertices::NumberOfVertices

(

void

)

Definition at line 255 of file Vertices.cpp.

                              {/*{{{*/
   return this->numberofvertices;
}/*}}}*/

NumberOfVerticesLocal()

int Vertices::NumberOfVerticesLocal

(

void

)

Definition at line 258 of file Vertices.cpp.

                                       {/*{{{*/
   return this->numberofmasters_local;
}/*}}}*/

NumberOfVerticesLocalAll()

int Vertices::NumberOfVerticesLocalAll

(

void

)

Definition at line 261 of file Vertices.cpp.

                                          {/*{{{*/
   return this->numberofvertices_local;
}/*}}}*/

LatLonList()

void Vertices::LatLonList	(	IssmDouble **	lat,
		IssmDouble **	lon
	)

Definition at line 135 of file Vertices.cpp.

                                                            {/*{{{*/
 
   /*output: */
   IssmDouble* xyz_serial=NULL;
 
   /*recover my_rank:*/
   int my_rank=IssmComm::GetRank();
 
   /*First, figure out number of vertices: */
   int num_vertices=this->NumberOfVertices();
 
   /*Now, allocate vectors*/
   Vector<IssmDouble>* lat = new Vector<IssmDouble>(num_vertices);
   Vector<IssmDouble>* lon = new Vector<IssmDouble>(num_vertices);
 
   /*Go through vertices, and for each vertex, object, report it cpu: */
   for(int i=0;i<this->Size();i++){
      Vertex* vertex=xDynamicCast<Vertex*>(this->GetObjectByOffset(i));
      lat->SetValue(vertex->sid,vertex->GetLatitude() ,INS_VAL);
      lon->SetValue(vertex->sid,vertex->GetLongitude(),INS_VAL);
   }
 
   /*Assemble:*/
   lat->Assemble();
   lon->Assemble();
 
   /*gather on cpu 0: */
   IssmDouble* lat_serial=lat->ToMPISerial();
   IssmDouble* lon_serial=lon->ToMPISerial();
 
   /*free ressources: */
   *plat = lat_serial;
   *plon = lon_serial;
   delete lat;
   delete lon;
}

Field Documentation

numberofvertices

int Vertices::numberofvertices

private

Definition at line 18 of file Vertices.h.

numberofvertices_local

int Vertices::numberofvertices_local

private

Definition at line 19 of file Vertices.h.

numberofmasters_local

int Vertices::numberofmasters_local

private

Definition at line 20 of file Vertices.h.

common_recv

int* Vertices::common_recv

Definition at line 22 of file Vertices.h.

common_recv_ids

int** Vertices::common_recv_ids

Definition at line 23 of file Vertices.h.

common_send

int* Vertices::common_send

Definition at line 24 of file Vertices.h.

common_send_ids

int** Vertices::common_send_ids

Definition at line 25 of file Vertices.h.

---

The documentation for this class was generated from the following files:

• src/c/classes/Vertices.h
• src/c/classes/Vertices.cpp