Ice Sheet System Model  4.18
Code documentation
Public Member Functions | Data Fields
FemModel Class Reference

#include <FemModel.h>

Public Member Functions

 FemModel (int argc, char **argv, ISSM_MPI_Comm comm_init, bool trace=false)
 
 FemModel (char *rootpath, char *inputfilename, char *outputfilename, char *toolkitsfilename, char *lockfilename, char *restartfilename, ISSM_MPI_Comm incomm, int solution_type, IssmPDouble *X)
 
 ~FemModel ()
 
int AnalysisIndex (int)
 
void CheckPoint (void)
 
void CleanUp (void)
 
FemModel * copy ()
 
void Echo ()
 
int GetElementsWidth ()
 
void InitFromFiles (char *rootpath, char *inputfilename, char *outputfilename, char *petscfilename, char *lockfilename, char *restartfilename, const int solution_type, bool trace, IssmPDouble *X=NULL)
 
void InitFromFids (char *rootpath, FILE *IOMODEL, FILE *toolkitsoptionsfid, int in_solution_type, bool trace, IssmPDouble *X=NULL)
 
void Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
 
void Restart (void)
 
void SetCurrentConfiguration (int configuration_type)
 
void SetCurrentConfiguration (int configuration_type, int analysis_type)
 
int Size (void)
 
void SolutionAnalysesList (int **panalyses, int *pnumanalyses, IoModel *iomodel, int solutiontype)
 
void Solve (void)
 
void BalancethicknessMisfitx (IssmDouble *pV)
 
void CalvingRateVonmisesx ()
 
void CalvingRateLevermannx ()
 
void CalvingFluxLevelsetx ()
 
void CalvingMeltingFluxLevelsetx ()
 
void DeviatoricStressx ()
 
void Divergencex (IssmDouble *pdiv)
 
void ElementOperationx (void(Element::*function)(void))
 
void ElementResponsex (IssmDouble *presponse, int response_enum)
 
void FloatingAreax (IssmDouble *pV, bool scaled)
 
void GetInputLocalMinMaxOnNodesx (IssmDouble **pmin, IssmDouble **pmax, IssmDouble *ug)
 
void GetLocalVectorWithClonesGset (IssmDouble **plocal_ug, Vector< IssmDouble > *ug)
 
void GetLocalVectorWithClonesVertices (IssmDouble **plocal_vector, Vector< IssmDouble > *vector)
 
void SyncLocalVectorWithClonesVertices (IssmDouble *local_vector)
 
void SyncLocalVectorWithClonesVerticesAdd (IssmDouble *local_vector)
 
void GetLocalVectorWithClonesNodes (IssmDouble **plocal_vector, Vector< IssmDouble > *vector)
 
void GroundedAreax (IssmDouble *pV, bool scaled)
 
void IcefrontAreax ()
 
void IcefrontMassFluxx (IssmDouble *presponse, bool scaled)
 
void IcefrontMassFluxLevelsetx (IssmDouble *presponse, bool scaled)
 
void GroundinglineMassFluxx (IssmDouble *presponse, bool scaled)
 
void IceMassx (IssmDouble *pV, bool scaled)
 
void IceVolumex (IssmDouble *pV, bool scaled)
 
void IceVolumeAboveFloatationx (IssmDouble *pV, bool scaled)
 
void InputMakeDiscontinuous (int enum_in)
 
void MassFluxx (IssmDouble *presponse)
 
void MaxAbsVxx (IssmDouble *presponse)
 
void MaxAbsVyx (IssmDouble *presponse)
 
void MaxAbsVzx (IssmDouble *presponse)
 
void MaxDivergencex (IssmDouble *pdiv)
 
void MaxVelx (IssmDouble *presponse)
 
void MaxVxx (IssmDouble *presponse)
 
void MaxVyx (IssmDouble *presponse)
 
void MaxVzx (IssmDouble *presponse)
 
void MinVelx (IssmDouble *presponse)
 
void MinVxx (IssmDouble *presponse)
 
void MinVyx (IssmDouble *presponse)
 
void MinVzx (IssmDouble *presponse)
 
void DistanceToFieldValue (int fieldenum, IssmDouble fieldvalue, int distanceenum)
 
void ResetLevelset ()
 
void StrainRateparallelx ()
 
void StrainRateperpendicularx ()
 
void StrainRateeffectivex ()
 
void StressIntensityFactorx ()
 
void RignotMeltParameterizationx ()
 
void TotalCalvingFluxLevelsetx (IssmDouble *pGbmb, bool scaled)
 
void TotalCalvingMeltingFluxLevelsetx (IssmDouble *pGbmb, bool scaled)
 
void TotalFloatingBmbx (IssmDouble *pFbmb, bool scaled)
 
void TotalGroundedBmbx (IssmDouble *pGbmb, bool scaled)
 
void TotalSmbx (IssmDouble *pSmb, bool scaled)
 
void CostFunctionx (IssmDouble *pJ, IssmDouble **pJlist, int *pn)
 
void OutputControlsx (Results **presults)
 
void RequestedDependentsx (void)
 
void RequestedOutputsx (Results **presults, char **requested_outputs, int numoutputs, bool save_results=true)
 
void RequestedOutputsx (Results **presults, int *requested_outputs, int numoutputs, bool save_results=true)
 
void Responsex (IssmDouble *presponse, int response_descriptor_enum)
 
void Responsex (IssmDouble *presponse, const char *response_descriptor)
 
void SurfaceAbsMisfitx (IssmDouble *pJ)
 
void OmegaAbsGradientx (IssmDouble *pJ)
 
void EtaDiffx (IssmDouble *pJ)
 
void ThicknessAverage ()
 
void ThicknessAbsGradientx (IssmDouble *pJ)
 
void ThicknessPositivex (IssmDouble *pJ)
 
void HydrologyEPLupdateDomainx (IssmDouble *pEplcount)
 
void HydrologyIDSupdateDomainx (IssmDouble *pIDScount)
 
void TimeAdaptx (IssmDouble *pdt)
 
void UpdateConstraintsExtrudeFromBasex ()
 
void UpdateConstraintsExtrudeFromTopx ()
 
void UpdateConstraintsL2ProjectionEPLx (IssmDouble *pL2count)
 
void InitTransientInputx (int *transientinput_enum, int numoutputs)
 
void StackTransientInputx (int *input_enum, int *transientinput_enum, IssmDouble hydrotime, int numoutputs)
 
void AverageTransientInputx (int *transientinput_enum, int *averagedinput_enum, IssmDouble init_time, IssmDouble end_time, int numoutputs, int averaging_method)
 
void UpdateConstraintsx (void)
 
int UpdateVertexPositionsx (void)
 
void ReMesh (void)
 
void BedrockFromMismipPlus (void)
 
void AdjustBaseThicknessAndMask (void)
 
void GetMesh (Vertices *femmodel_vertices, Elements *femmodel_elements, IssmDouble **px, IssmDouble **py, int **pelementslist)
 
void GetMesh (int **elementslist, IssmDouble **x, IssmDouble **y, int *numberofvertices, int *numberofelements)
 
void SetMesh (int **elementslist, IssmDouble **x, IssmDouble **y, int *numberofvertices, int *numberofelements)
 
void GetMeshOnPartition (Vertices *femmodel_vertices, Elements *femmodel_elements, IssmDouble **px, IssmDouble **py, IssmDouble **pz, int **pelementslist, int **psidtoindex)
 
void CreateElements (int newnumberofelements, int elementswidth, int *newelementslist, bool *my_elements, Elements *elements)
 
void CreateMaterials (int newnumberofelements, bool *my_elements, Materials *materials)
 
void CreateConstraints (Vertices *newfemmodel_vertices, int analysis_enum, Constraints *newfemmodel_constraints)
 
void GetInputs (int *pnumP0inputs, IssmDouble **pP0inputs, int **pP0input_enums, int **pP0input_interp, int *pnumP1inputs, IssmDouble **pP1inputs, int **pP1input_enums, int **pP1input_interp)
 
void InterpolateInputs (Vertices *newfemmodel_vertices, Elements *newfemmodel_elements, Inputs2 *new_inputs)
 
void UpdateElements (int newnumberofelements, int *newelementslist, bool *my_elements, int analysis_counter, Elements *newelements)
 
void WriteMeshInResults (void)
 
void WriteErrorEstimatorsInResults (void)
 
void SmoothedDeviatoricStressTensor (IssmDouble **ptauxx, IssmDouble **ptauyy, IssmDouble **ptauxy)
 
void ZZErrorEstimator (IssmDouble **pelementerror)
 
void SmoothedGradThickness (IssmDouble **pdHdx, IssmDouble **pdHdy)
 
void ThicknessZZErrorEstimator (IssmDouble **pelementerror)
 
void MeanGroundedIceLevelSet (IssmDouble **pmasklevelset)
 
void GetElementCenterCoordinates (IssmDouble **pxc, IssmDouble **pyc)
 
void GetZeroLevelSetPoints (IssmDouble **pzerolevelset_points, int &numberofpoints, int levelset_type)
 

Data Fields

int analysis_counter
 
int * analysis_type_list
 
int nummodels
 
int solution_type
 
Profiler * profiler
 
Elements * elements
 
Materials * materials
 
Parameters * parameters
 
Inputs2 * inputs2
 
Results * results
 
Vertices * vertices
 
Constraints * constraints
 
Constraints ** constraints_list
 
Loads * loads
 
Loads ** loads_list
 
Nodes * nodes
 
Nodes ** nodes_list
 

Detailed Description

Definition at line 31 of file FemModel.h.

Constructor & Destructor Documentation

◆ FemModel() [1/2]

FemModel::FemModel ( int  argc,
char **  argv,
ISSM_MPI_Comm  comm_init,
bool  trace = false 
)

Definition at line 56 of file FemModel.cpp.

56  {/*{{{*/
57 
58  /*configuration: */
59  int solution_type,amrtype,amr_frequency;
60  int ierr;
61 
62  /*File names*/
63  char *lockfilename = NULL;
64  char *binfilename = NULL;
65  char *outbinfilename = NULL;
66  char *petscfilename = NULL;
67  char *restartfilename = NULL;
68  char *rootpath = NULL;
69 
70  /*First things first, store the communicator, and set it as a global variable: */
71  IssmComm::SetComm(incomm);
72 
73  /*Now, initialize PETSC: */
74  #ifdef _HAVE_PETSC_
75  PETSC_COMM_WORLD=incomm;
76  ierr=PetscInitialize(&argc,&argv,(char*)0,""); if(ierr) _error_("Could not initialize Petsc");
77  #endif
78 
79  /*Start profiler: */
80  this->profiler=new Profiler();
81  profiler->Start(TOTAL);
82 
83  /*From command line arguments, retrieve different filenames needed to create the FemModel: */
84  ProcessArguments(&solution_type,&binfilename,&outbinfilename,&petscfilename,&lockfilename,&restartfilename,&rootpath,argc,argv);
85 
86  /*Create femmodel from input files: */
87  profiler->Start(MPROCESSOR);
88  this->InitFromFiles(rootpath,binfilename,outbinfilename,petscfilename,lockfilename,restartfilename, solution_type,trace,NULL);
89  profiler->Stop(MPROCESSOR);
90 
91  /*Save communicator in the parameters dataset: */
92  this->parameters->AddObject(new GenericParam<ISSM_MPI_Comm>(incomm,FemModelCommEnum));
93 
94  /*AMR stuff*/
95  this->parameters->FindParam(&amr_frequency,TransientAmrFrequencyEnum);
96  this->parameters->FindParam(&amr_frequency,TransientAmrFrequencyEnum);
97  #if defined(_HAVE_NEOPZ_) && !defined(_HAVE_AD_)
98  this->amr = NULL;
99  #endif
100  #if defined(_HAVE_BAMG_) && !defined(_HAVE_AD_)
101  this->amrbamg = NULL;
102  #endif
103  #if !defined(_HAVE_AD_)
104  if(amr_frequency && solution_type==TransientSolutionEnum){
105  /*Verifications. AMR supports SSA, P1 and horizontal 2D domain*/
106  bool isSSA;
107  int domaintype,element_type;
108  this->analysis_counter=-1;
109  this->parameters->FindParam(&isSSA,FlowequationIsSSAEnum);
110  this->parameters->FindParam(&domaintype,DomainTypeEnum);
111  for(int i=0;i<this->nummodels;i++) if(this->analysis_type_list[i]==StressbalanceAnalysisEnum){analysis_counter=i;break;}
112  if(analysis_counter==-1) _error_("Could not find alias for analysis_type StressbalanceAnalysisEnum in list of FemModel analyses\n");
113  for(int i=0;i<this->elements->Size();i++){
114  Element* element = xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
115  element_type = element->element_type_list[analysis_counter];
116  if(element_type!=P1Enum) _error_("Element type "<<EnumToStringx(element_type)<<" not supported with AMR yet!\n");
117  }
118  if(!isSSA) _error_("Flow equation not supported with AMR yet!\n ");
119  if(domaintype!=Domain2DhorizontalEnum) _error_("Domain "<<EnumToStringx(domaintype)<<" not supported with AMR yet!\n");
120 
121  this->parameters->FindParam(&amrtype,AmrTypeEnum);
122  switch(amrtype){
123 
124  #if defined(_HAVE_NEOPZ_)
125  case AmrNeopzEnum: this->InitializeAdaptiveRefinementNeopz(); break;
126  #endif
127 
128  #if defined(_HAVE_BAMG_)
129  case AmrBamgEnum: this->InitializeAdaptiveRefinementBamg(); break;
130  #endif
131 
132  default: _error_("not implemented yet");
133  }
134  }
135  #endif
136 
137  /*Free resources */
138  xDelete<char>(lockfilename);
139  xDelete<char>(binfilename);
140  xDelete<char>(outbinfilename);
141  xDelete<char>(petscfilename);
142  xDelete<char>(restartfilename);
143  xDelete<char>(rootpath);
144 
145 }

◆ FemModel() [2/2]

FemModel::FemModel ( char *  rootpath,
char *  inputfilename,
char *  outputfilename,
char *  toolkitsfilename,
char *  lockfilename,
char *  restartfilename,
ISSM_MPI_Comm  incomm,
int  solution_type,
IssmPDouble *  X 
)

Definition at line 147 of file FemModel.cpp.

147  { /*{{{*/
148 
149  bool traceon=true;
150  this->profiler=NULL; /*avoid leak, as we are not using the profiler ever in ad control run. */
151 
152  /*Store the communicator, but do not set it as a global variable, as this has already
153  * been done by the FemModel that called this copy constructor: */
154  IssmComm::SetComm(incomm);
155 
156  /*Create femmodel from input files, with trace activated: */
157  profiler->Start(MPROCESSOR);
158  this->InitFromFiles(rootpath,inputfilename,outputfilename,toolkitsfilename,lockfilename,restartfilename, solution_type,traceon,X);
159  profiler->Stop(MPROCESSOR);
160 
161  #if defined(_HAVE_NEOPZ_) && !defined(_HAVE_AD_)
162  this->amr = NULL;
163  #endif
164  #if defined(_HAVE_BAMG_) && !defined(_HAVE_AD_)
165  this->amrbamg = NULL;
166  #endif
167 
168  /*Save communicator in the parameters dataset: */
169  this->parameters->AddObject(new GenericParam<ISSM_MPI_Comm>(incomm,FemModelCommEnum));
170 }

◆ ~FemModel()

FemModel::~FemModel ( )

Definition at line 172 of file FemModel.cpp.

172  {/*{{{*/
173 
174  /*Intermediary*/
175  FILE *output_fid;
176  char *outbinfilename = NULL;
177  char *lockfilename = NULL;
178 
179  #ifndef _HAVE_JAVASCRIPT_
180  if(this->parameters->Exist(OutputFileNameEnum)) this->parameters->FindParam(&outbinfilename,OutputFileNameEnum);
181  if(this->parameters->Exist(LockFileNameEnum)) this->parameters->FindParam(&lockfilename,LockFileNameEnum);
182  #endif
183 
184  /*Delete all the datasets: */
185  if(analysis_type_list)xDelete<int>(analysis_type_list);
186  if(outbinfilename)xDelete<char>(outbinfilename);
187  if(lockfilename)xDelete<char>(lockfilename);
188  if(elements)delete elements;
189  if(vertices)delete vertices;
190  if(this->constraints_list && this->nummodels){
191  for(int i=0;i<this->nummodels;i++) delete this->constraints_list[i];
192  xDelete<Constraints*>(constraints_list);
193  }
194  if(this->loads_list && this->nummodels){
195  for(int i=0;i<this->nummodels;i++) delete this->loads_list[i];
196  xDelete<Loads*>(loads_list);
197  }
198  if(this->nodes_list && this->nummodels){
199  for(int i=0;i<this->nummodels;i++) delete this->nodes_list[i];
200  xDelete<Nodes*>(nodes_list);
201  }
202  if(materials)delete materials;
203  if(parameters)delete parameters;
204  if(inputs2)delete inputs2;
205  if(results)delete results;
206 
207  #if defined(_HAVE_NEOPZ_) && !defined(_HAVE_AD_)
208  if(amr)delete amr;
209  #endif
210 
211  #if defined(_HAVE_BAMG_) && !defined(_HAVE_AD_)
212  if(amrbamg)delete amrbamg;
213  #endif
214 
215  /*Now delete: */
216  if(profiler)delete profiler;
217 }/*}}}*/

Member Function Documentation

◆ AnalysisIndex()

int FemModel::AnalysisIndex ( int  analysis_enum)

Definition at line 220 of file FemModel.cpp.

220  {/*{{{*/
221 
222  /*Checks in debugging mode*/
223  _assert_(this->analysis_type_list);
224 
225  /*Find analysis in list*/
226  for(int i=0;i<this->nummodels;i++){
227  if(this->analysis_type_list[i]==analysis_enum){
228  return i;
229  break;
230  }
231  }
232 
233  /*If you reach this point, analysis has not been found*/
234  _error_("Could not find index of analysis " << EnumToStringx(analysis_enum) << " in list of FemModel analyses");
235 
236 
237 }/*}}}*/

◆ CheckPoint()

void FemModel::CheckPoint ( void  )

Definition at line 238 of file FemModel.cpp.

238  {/*{{{*/
239 
240  FILE* restartfid=NULL;
241  char* restartfilename = NULL;
242  int femmodel_size;
243  char* femmodel_buffer=NULL;
244  char* femmodel_buffer_ini=NULL;
245 
246  /*First, recover the name of the restart file: */
247  parameters->FindParam(&restartfilename,RestartFileNameEnum);
248 
249  /*Open file for writing: */
250  restartfid=pfopen(restartfilename,"wb");
251 
252  /*Initialize: */
253  femmodel_size=0;
254 
255  /*Create buffer to hold marshalled femmodel: */
256  this->Marshall(NULL,&femmodel_size,MARSHALLING_SIZE);
257  femmodel_buffer=xNew<char>(femmodel_size);
258  /*Keep track of initial position of femmodel_buffer: */
259  femmodel_buffer_ini=femmodel_buffer;
260 
261  /*Marshall:*/
262  this->Marshall(&femmodel_buffer,NULL,MARSHALLING_FORWARD);
263 
264  /*Reset position of buffer: */
265  femmodel_buffer=femmodel_buffer_ini;
266 
267  /*write buffer: */
268  fwrite(femmodel_buffer,femmodel_size,sizeof(char),restartfid);
269 
270  /*Done, close file :*/
271  pfclose(restartfid,restartfilename);
272 
273  /*Free ressources: */
274  xDelete<char>(femmodel_buffer);
275  xDelete<char>(restartfilename);
276 
277 }

◆ CleanUp()

void FemModel::CleanUp ( void  )

Definition at line 279 of file FemModel.cpp.

279  {/*{{{*/
280 
281  /*Intermediary*/
282  char *lockfilename = NULL;
283  bool waitonlock = false;
284 
285  /*Write lock file if requested: */
286  this->parameters->FindParam(&waitonlock,SettingsWaitonlockEnum);
287  this->parameters->FindParam(&lockfilename,LockFileNameEnum);
288  if(waitonlock){
289  _printf0_("write lock file:\n");
290  WriteLockFile(lockfilename);
291  }
292 
293  /*Before we delete the profiler, report statistics for this run: */
294  profiler->Stop(TOTAL); //final tagging
295 
296  _printf0_("\n");
297  _printf0_(" "<<setw(40)<<left<<"FemModel initialization elapsed time:"<<setw(7)<<profiler->TotalTime(MPROCESSOR) << "\n");
298  /*Total times*/
299  _printf0_(" "<<setw(40)<<left<<"Total Core solution elapsed time:"<<setw(7)<<profiler->TotalTime(CORE) << "\n");
300 
301  /*Linear solver only*/
302  _printf0_(" "<<setw(40)<<left<<"Linear solver elapsed time:"<<setw(7)<<profiler->TotalTime(SOLVER) << " ("<<setprecision(2)<<profiler->TotalTime(SOLVER)/profiler->TotalTime(CORE)*100.<<"%)\n");
303  _printf0_("\n");
304  _printf0_(" Total elapsed time: "
305  <<profiler->TotalTimeModHour(TOTAL)<<" hrs "
306  <<profiler->TotalTimeModMin(TOTAL)<<" min "
307  <<profiler->TotalTimeModSec(TOTAL)<<" sec"
308  );
309  _printf0_("\n");
310 
311  /*Finalize PETSC for this model: */
312  #ifdef _HAVE_PETSC_
313  //_printf0_("closing PETSc\n");
314  PetscFinalize();
315  #endif
316 
317  /*Clean up*/
318  xDelete<char>(lockfilename);
319 } /*}}}*/

◆ copy()

FemModel * FemModel::copy ( void  )

Definition at line 320 of file FemModel.cpp.

320  {/*{{{*/
321 
322  FemModel* output=NULL;
323  int i;
324  int analysis_type;
325 
326  output=new FemModel(*this); //Use default copy constructor.
327 
328  output->nummodels = this->nummodels;
329  output->solution_type = this->solution_type;
330  output->analysis_counter = this->analysis_counter;
331 
332  /*Now, deep copy arrays: */
333  output->analysis_type_list=xNew<int>(nummodels);
334  xMemCpy<int>(output->analysis_type_list,this->analysis_type_list,this->nummodels);
335 
336  /*Analysis dependent arrays*/
337  output->constraints_list=xNew<Constraints*>(this->nummodels);
338  output->loads_list=xNew<Loads*>(this->nummodels);
339  output->nodes_list=xNew<Nodes*>(this->nummodels);
340 
341  output->profiler=static_cast<Profiler*>(this->profiler->copy());
342 
343  output->materials=static_cast<Materials*>(this->materials->Copy());
344  output->parameters=static_cast<Parameters*>(this->parameters->Copy());
345  output->inputs2=static_cast<Inputs2*>(this->inputs2->Copy());
346  output->results=static_cast<Results*>(this->results->Copy());
347  output->vertices=static_cast<Vertices*>(this->vertices->Copy());
348  output->elements=static_cast<Elements*>(this->elements->Copy());
349 
350  /*reset hooks for elements, loads and nodes: */
351  output->elements->ResetHooks();
352  output->loads->ResetHooks();
353  output->materials->ResetHooks();
354 
355  /*do the post-processing of the datasets to get an FemModel that can actually run analyses: */
356  for(i=0;i<nummodels;i++){
357  output->constraints_list[i] = static_cast<Constraints*>(this->constraints_list[i]->Copy());
358  output->loads_list[i] = static_cast<Loads*>(this->loads_list[i]->Copy());
359  output->nodes_list[i] = static_cast<Nodes*>(this->nodes_list[i]->Copy());
360  analysis_type=output->analysis_type_list[i];
361  output->SetCurrentConfiguration(analysis_type);
362  SpcNodesx(output->nodes_list[i],output->constraints_list[i],output->parameters);
363  NodesDofx(output->nodes_list[i],output->parameters);
364  ConfigureObjectsx(output->elements,output->loads_list[i],output->nodes_list[i],output->vertices,output->materials,output->parameters,output->inputs2);
365  }
366 
367  /*AMR, no copy for now*/
368  #if defined(_HAVE_NEOPZ_) && !defined(_HAVE_AD_)
369  this->amr = NULL;
370  #endif
371  #if defined(_HAVE_BAMG_) && !defined(_HAVE_AD_)
372  this->amrbamg = NULL;
373  #endif
374 
375  /*Reset current configuration: */
376  analysis_type=output->analysis_type_list[analysis_counter];
377  output->SetCurrentConfiguration(analysis_type);
378 
379  return output;
380 }

◆ Echo()

void FemModel::Echo ( void  )

Definition at line 382 of file FemModel.cpp.

382  {/*{{{*/
383 
384  _printf_("FemModel echo: \n");
385  _printf_(" number of fem models: " << nummodels << "\n");
386  _printf_(" analysis_type_list: \n");
387  for(int i=0;i<nummodels;i++)_printf_(" " << i << ": " << EnumToStringx(analysis_type_list[i]) << "\n");
388  _printf_(" current analysis_type: \n");
389  _printf_(" " << analysis_counter << ": " << EnumToStringx(analysis_type_list[analysis_counter]) << "\n");
390 
391 }

◆ GetElementsWidth()

int FemModel::GetElementsWidth ( )
inline

Definition at line 79 of file FemModel.h.

79 {return 3;};//just tria elements in this first version

◆ InitFromFiles()

void FemModel::InitFromFiles ( char *  rootpath,
char *  inputfilename,
char *  outputfilename,
char *  petscfilename,
char *  lockfilename,
char *  restartfilename,
const int  solution_type,
bool  trace,
IssmPDouble *  X = NULL 
)

Definition at line 393 of file FemModel.cpp.

393  {/*{{{*/
394 
395  /*intermediary*/
396  FILE *IOMODEL = NULL;
397  FILE *toolkitsoptionsfid = NULL;
398 
399  /*recover my_rank:*/
400  int my_rank=IssmComm::GetRank();
401 
402  /*Open input file descriptor on cpu 0: */
403  if(my_rank==0) IOMODEL = pfopen0(inputfilename ,"rb");
404 
405  /*Open toolkits file: */
406  toolkitsoptionsfid=pfopen(toolkitsfilename,"r");
407 
408  /*Now, go create FemModel:*/
409  this->InitFromFids(rootpath,IOMODEL,toolkitsoptionsfid,in_solution_type,trace,X);
410 
411  /*Close input file and toolkits file descriptors: */
412  if(my_rank==0) pfclose(IOMODEL,inputfilename);
413  pfclose(toolkitsoptionsfid,toolkitsfilename);
414 
415  /*Now save all of these file names into parameters, you never know when you might need them: */
416  this->parameters->AddObject(new StringParam(ToolkitsFileNameEnum,toolkitsfilename));
417  this->parameters->AddObject(new StringParam(RootPathEnum,rootpath));
418  this->parameters->AddObject(new StringParam(InputFileNameEnum,inputfilename));
419  this->parameters->AddObject(new StringParam(OutputFileNameEnum,outputfilename));
420  this->parameters->AddObject(new StringParam(LockFileNameEnum,lockfilename));
421  this->parameters->AddObject(new StringParam(RestartFileNameEnum,restartfilename));
422 
423 }/*}}}*/

◆ InitFromFids()

void FemModel::InitFromFids ( char *  rootpath,
FILE *  IOMODEL,
FILE *  toolkitsoptionsfid,
int  in_solution_type,
bool  trace,
IssmPDouble *  X = NULL 
)

Definition at line 424 of file FemModel.cpp.

424  {/*{{{*/
425 
426  /*Initialize internal data: */
427  this->solution_type = in_solution_type;
428  this->analysis_counter = -1;
429  this->results = new Results(); //not initialized by CreateDataSets
430 
431  /*create IoModel */
432  IoModel* iomodel = new IoModel(IOMODEL,in_solution_type,trace,X);
433 
434  /*Figure out what analyses are activated for this solution*/
435  SolutionAnalysesList(&this->analysis_type_list,&this->nummodels,iomodel,this->solution_type);
436 
437  /*create datasets for all analyses*/
438  ModelProcessorx(&this->elements,&this->nodes_list,&this->vertices,&this->materials,&this->constraints_list,&this->loads_list,&this->parameters,&this->inputs2,iomodel,toolkitsoptionsfid,rootpath,this->solution_type,this->nummodels,this->analysis_type_list);
439 
440  /*do the post-processing of the datasets to get an FemModel that can actually run analyses: */
441  for(int i=0;i<nummodels;i++){
442 
443  if(VerboseMProcessor()) _printf0_(" Processing finite element model of analysis " << EnumToStringx(analysis_type_list[i]) << ":\n");
444  this->SetCurrentConfiguration(analysis_type_list[i]);
445 
446  if(VerboseMProcessor()) _printf0_(" configuring element and loads\n");
447  ConfigureObjectsx(this->elements,this->loads,this->nodes,this->vertices,this->materials,this->parameters,this->inputs2);
448 
449  if(i==0){
450  if(VerboseMProcessor()) _printf0_(" detecting active vertices\n");
451  GetMaskOfIceVerticesLSMx0(this);
452  }
453 
454  if(VerboseMProcessor()) _printf0_(" resolving node constraints\n");
455  SpcNodesx(nodes,this->constraints,parameters);
456 
457  if(VerboseMProcessor()) _printf0_(" creating nodal degrees of freedom\n");
458  NodesDofx(nodes,parameters);
459  }
460 
461  /*Clean up*/
462  delete iomodel;
463 }/*}}}*/

◆ Marshall()

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

Definition at line 464 of file FemModel.cpp.

464  { /*{{{*/
465 
466  int i;
467  int analysis_type;
468 
469  if(marshall_direction==MARSHALLING_BACKWARD){
470  delete this->materials;
471  delete this->parameters;
472  delete this->inputs2;
473  if(this->constraints_list && this->nummodels){
474  for(i=0;i<this->nummodels;i++) delete this->constraints_list[i];
475  xDelete<Constraints*>(constraints_list);
476  }
477  if(this->loads_list && this->nummodels){
478  for(i=0;i<this->nummodels;i++) delete this->loads_list[i];
479  xDelete<Loads*>(loads_list);
480  }
481  if(this->nodes_list && this->nummodels){
482  for(i=0;i<this->nummodels;i++) delete this->nodes_list[i];
483  xDelete<Nodes*>(nodes_list);
484  }
485  delete this->results;
486  delete this->vertices;
487  delete this->elements;
488  xDelete<int>(this->analysis_type_list);
489 
490  this->materials = new Materials();
491  this->parameters = new Parameters();
492  this->inputs2 = new Inputs2();
493  this->results = new Results();
494  this->nodes = new Nodes();
495  this->vertices = new Vertices();
496  this->elements = new Elements();
497  }
498 
499  MARSHALLING_ENUM(FemModelEnum);
500 
501  MARSHALLING(solution_type);
502  MARSHALLING(analysis_counter);
503  MARSHALLING(nummodels);
504  MARSHALLING_DYNAMIC(analysis_type_list,int,nummodels);
505 
506  this->materials->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
507  this->parameters->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
508  this->inputs2->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
509  this->results->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
510  this->vertices->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
511  this->elements->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
512 
513  if(marshall_direction==MARSHALLING_BACKWARD){
514  this->constraints_list = xNew<Constraints*>(this->nummodels);
515  for(i=0;i<nummodels;i++) this->constraints_list[i] = new Constraints();
516  this->loads_list = xNew<Loads*>(this->nummodels);
517  for(i=0;i<nummodels;i++) this->loads_list[i] = new Loads();
518  this->nodes_list = xNew<Nodes*>(this->nummodels);
519  for(i=0;i<nummodels;i++) this->nodes_list[i] = new Nodes();
520  }
521 
522  for(i=0;i<nummodels;i++){
523  this->constraints_list[i]->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
524  this->loads_list[i]->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
525  this->nodes_list[i]->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
526  }
527 
528  if(marshall_direction==MARSHALLING_BACKWARD){
529  /*reset hooks for elements, loads and nodes:*/
530  this->elements->ResetHooks();
531  this->materials->ResetHooks();
532 
533  /*do the post-processing of the datasets to get an FemModel that can actually run analyses:*/
534  for(i=0;i<nummodels;i++){
535  this->loads_list[i]->ResetHooks();
536  analysis_type=this->analysis_type_list[i];
537  SetCurrentConfiguration(analysis_type);
538  SpcNodesx(this->nodes_list[i],this->constraints_list[i],this->parameters);
539  NodesDofx(this->nodes_list[i],this->parameters);
540  ConfigureObjectsx(this->elements,this->loads_list[i],this->nodes_list[i],this->vertices,this->materials,this->parameters,this->inputs2);
541  }
542 
543  //Reset current configuration:
544  analysis_type=this->analysis_type_list[analysis_counter];
545  SetCurrentConfiguration(analysis_type);
546  }
547 }

◆ Restart()

void FemModel::Restart ( void  )

Definition at line 549 of file FemModel.cpp.

549  { /*{{{*/
550 
551  FILE* restartfid=NULL;
552  char* restartfilename = NULL;
553  int femmodel_size=0;
554  int fread_return=0;
555  char* femmodel_buffer=NULL;
556  char* femmodel_buffer_ini=NULL;
557 
558  /*First, recover the name of the restart file: */
559  parameters->FindParam(&restartfilename,RestartFileNameEnum);
560 
561  /*Now, figure out whether this file actually exists!: */
562  restartfid=pfopen(restartfilename,"r",false);
563 
564  if(restartfid==NULL){
565  xDelete<char>(restartfilename);
566  return; //could not find the file, so no restart possible.
567  }
568 
569  /*Print banner*/
570  _printf0_(" \n");
571  _printf0_("====================================================================\n");
572  _printf0_(" RESTART DETECTED \n");
573  _printf0_(" \n");
574  _printf0_(" Restart file: "<<restartfilename<<" \n");
575  _printf0_("====================================================================\n");
576  _printf0_(" \n");
577 
578  /*Figure out size of buffer to be read: */
579  fseek(restartfid, 0L, SEEK_END);
580  femmodel_size = ftell(restartfid);
581  fseek(restartfid, 0L, SEEK_SET);
582 
583  /*Allocate buffer: */
584  femmodel_buffer=xNew<char>(femmodel_size);
585 
586  /*Read buffer from file: */
587  fread_return=fread(femmodel_buffer,femmodel_size,sizeof(char),restartfid); if(fread_return!=1)_error_("error reading the buffer from marshalled file!");
588  femmodel_buffer_ini=femmodel_buffer; //keep track of the initial position, so as to free later.
589 
590  /*Create new FemModel by demarshalling the buffer: */
591  this->Marshall(&femmodel_buffer,NULL,MARSHALLING_BACKWARD);
592 
593  /*Reset position of buffer: */
594  femmodel_buffer=femmodel_buffer_ini;
595 
596  /*Done, close file :*/
597  pfclose(restartfid,restartfilename);
598 
599  /*Free ressources: */
600  xDelete<char>(restartfilename);
601  xDelete<char>(femmodel_buffer);
602 }/*}}}*/

◆ SetCurrentConfiguration() [1/2]

void FemModel::SetCurrentConfiguration ( int  configuration_type)

Definition at line 634 of file FemModel.cpp.

634  {/*{{{*/
635  this->SetCurrentConfiguration(configuration_type,configuration_type);
636 }

◆ SetCurrentConfiguration() [2/2]

void FemModel::SetCurrentConfiguration ( int  configuration_type,
int  analysis_type 
)

Definition at line 603 of file FemModel.cpp.

603  {/*{{{*/
604 
605  /*Use configuration_type to setup the analysis counter, the configurations of objects etc ... but use
606  * analysis_type to drive the element numerics. This allows for use of 1 configuration_type for several
607  * analyses. For example: do a SurfaceSlopeX, SurfaceSlopeY, BedSlopeX and BedSlopeY analysis using the
608  * Slope configuration.*/
609  int index = AnalysisIndex(configuration_type);
610 
611  /*If we already have the right analysis, return*/
612  //if(this->analysis_counter==index) return;
613  this->analysis_counter=index;
614 
615  /*Now, plug analysis_counter and analysis_type inside the parameters: */
616  this->parameters->SetParam(analysis_counter,AnalysisCounterEnum);
617  this->parameters->SetParam(analysis_type,AnalysisTypeEnum);
618  this->parameters->SetParam(configuration_type,ConfigurationTypeEnum);
619 
620  /*configure elements, loads and nodes, for this new analysis: */
621  this->loads = this->loads_list[this->analysis_counter];
622  this->constraints = this->constraints_list[this->analysis_counter];
623  this->nodes = this->nodes_list[this->analysis_counter];
624  this->loads->SetCurrentConfiguration(elements, loads, nodes,vertices, materials,parameters);
625  this->elements->SetCurrentConfiguration(elements,loads, nodes,vertices, materials,parameters);
626 
627  /*take care of toolkits options, that depend on this analysis type (present only after model processor)*/
628  if(this->parameters->Exist(ToolkitsOptionsStringsEnum)){
629  ToolkitsOptionsFromAnalysis(this->parameters,analysis_type);
630  if(VerboseSolver()) _printf0_(" toolkits Options set for analysis: " << EnumToStringx(analysis_type) << "\n");
631  }
632 
633 }/*}}}*/

◆ Size()

int FemModel::Size ( void  )

Definition at line 638 of file FemModel.cpp.

638  { /*{{{*/
639  int femmodel_size;
640 
641  this->Marshall(NULL,&femmodel_size,MARSHALLING_SIZE);
642 
643  return femmodel_size;
644 }

◆ SolutionAnalysesList()

void FemModel::SolutionAnalysesList ( int **  panalyses,
int *  pnumanalyses,
IoModel *  iomodel,
int  solutiontype 
)

Definition at line 646 of file FemModel.cpp.

646  {/*{{{*/
647 
648  /*output: */
649  int numanalyses = 0;
650  int *analyses = NULL;
651 
652  /*Intermediaries*/
653  const int MAXANALYSES = 30;
654  int analyses_temp[MAXANALYSES];
655 
656  /*Analyses lists*/
657  switch(solutiontype){
658 
659  case StressbalanceSolutionEnum:{
660  bool isSIA,isFS;
661  int fe_FS;
662  iomodel->FindConstant(&fe_FS,"md.flowequation.fe_FS");
663  iomodel->FindConstant(&isSIA,"md.flowequation.isSIA");
664  iomodel->FindConstant(&isFS,"md.flowequation.isFS");
665  analyses_temp[numanalyses++]=StressbalanceAnalysisEnum;
666  analyses_temp[numanalyses++]=StressbalanceVerticalAnalysisEnum;
667  if(isSIA){
668  analyses_temp[numanalyses++]=StressbalanceSIAAnalysisEnum;
669  }
670  analyses_temp[numanalyses++]=L2ProjectionBaseAnalysisEnum;
671  analyses_temp[numanalyses++]=ExtrudeFromBaseAnalysisEnum;
672  analyses_temp[numanalyses++]=DepthAverageAnalysisEnum;
673  if(fe_FS==LATaylorHoodEnum || fe_FS==LACrouzeixRaviartEnum){
674  analyses_temp[numanalyses++]=UzawaPressureAnalysisEnum;
675  }
676  }
677  break;
678 
679  case SteadystateSolutionEnum:{
680  bool isSIA,isenthalpy;
681  iomodel->FindConstant(&isSIA,"md.flowequation.isSIA");
682  iomodel->FindConstant(&isenthalpy,"md.thermal.isenthalpy");
683  analyses_temp[numanalyses++]=StressbalanceAnalysisEnum;
684  analyses_temp[numanalyses++]=StressbalanceVerticalAnalysisEnum;
685  if(isSIA){
686  analyses_temp[numanalyses++]=StressbalanceSIAAnalysisEnum;
687  }
688  if(isenthalpy){
689  analyses_temp[numanalyses++]=EnthalpyAnalysisEnum;
690  }
691  else{
692  analyses_temp[numanalyses++]=ThermalAnalysisEnum;
693  analyses_temp[numanalyses++]=MeltingAnalysisEnum;
694  }
695  analyses_temp[numanalyses++]=L2ProjectionBaseAnalysisEnum;
696  }
697  break;
698 
699  case ThermalSolutionEnum:{
700  bool isenthalpy;
701  iomodel->FindConstant(&isenthalpy,"md.thermal.isenthalpy");
702  if(isenthalpy){
703  analyses_temp[numanalyses++]=EnthalpyAnalysisEnum;
704  }
705  else{
706  analyses_temp[numanalyses++]=ThermalAnalysisEnum;
707  analyses_temp[numanalyses++]=MeltingAnalysisEnum;
708  }
709  }
710  break;
711 
712  case HydrologySolutionEnum:{
713  int hydrology_model;
714  iomodel->FindConstant(&hydrology_model,"md.hydrology.model");
715  if(hydrology_model==HydrologyshreveEnum){
716  analyses_temp[numanalyses++]=HydrologyShreveAnalysisEnum;
717  }
718  else if(hydrology_model==HydrologyGlaDSEnum){
719  analyses_temp[numanalyses++]=HydrologyGlaDSAnalysisEnum;
720  }
721  if(hydrology_model==HydrologyshaktiEnum){
722  analyses_temp[numanalyses++]=HydrologyShaktiAnalysisEnum;
723  }
724  if(hydrology_model==HydrologypismEnum){
725  analyses_temp[numanalyses++]=HydrologyPismAnalysisEnum;
726  }
727  if(hydrology_model==HydrologydcEnum){
728  analyses_temp[numanalyses++]=HydrologyDCInefficientAnalysisEnum;
729  analyses_temp[numanalyses++]=HydrologyDCEfficientAnalysisEnum;
730  analyses_temp[numanalyses++]=L2ProjectionEPLAnalysisEnum;
731  analyses_temp[numanalyses++]=L2ProjectionBaseAnalysisEnum;
732  }
733  }
734  break;
735 
736  case MasstransportSolutionEnum:
737  analyses_temp[numanalyses++]=DepthAverageAnalysisEnum;
738  analyses_temp[numanalyses++]=SmbAnalysisEnum;
739  analyses_temp[numanalyses++]=MasstransportAnalysisEnum;
740  analyses_temp[numanalyses++]=ExtrudeFromBaseAnalysisEnum;
741 
742  break;
743 
744  case BalancethicknessSolutionEnum:
745  analyses_temp[numanalyses++]=BalancethicknessAnalysisEnum;
746  break;
747 
748  case Balancethickness2SolutionEnum:
749  analyses_temp[numanalyses++]=L2ProjectionBaseAnalysisEnum;
750  analyses_temp[numanalyses++]=SmoothAnalysisEnum;
751  analyses_temp[numanalyses++]=Balancethickness2AnalysisEnum;
752  break;
753 
754  case BalancethicknessSoftSolutionEnum:
755  analyses_temp[numanalyses++]=BalancethicknessAnalysisEnum;
756  break;
757 
758  case BalancevelocitySolutionEnum:
759  analyses_temp[numanalyses++]=BalancevelocityAnalysisEnum;
760  analyses_temp[numanalyses++]=SmoothAnalysisEnum;
761  break;
762 
763  case SurfaceSlopeSolutionEnum:
764  analyses_temp[numanalyses++]=L2ProjectionBaseAnalysisEnum;
765  break;
766 
767  case BedSlopeSolutionEnum:
768  analyses_temp[numanalyses++]=L2ProjectionBaseAnalysisEnum;
769  break;
770 
771  case GiaSolutionEnum:
772  analyses_temp[numanalyses++]=GiaAnalysisEnum;
773  break;
774 
775  case LoveSolutionEnum:
776  analyses_temp[numanalyses++]=LoveAnalysisEnum;
777  break;
778 
779  case EsaSolutionEnum:
780  analyses_temp[numanalyses++]=EsaAnalysisEnum;
781  break;
782 
783  case SealevelriseSolutionEnum:
784  analyses_temp[numanalyses++]=SealevelriseAnalysisEnum;
785  analyses_temp[numanalyses++]=GiaAnalysisEnum;
786  break;
787 
788  case SmbSolutionEnum:
789  analyses_temp[numanalyses++]=SmbAnalysisEnum;
790  break;
791 
792  case DamageEvolutionSolutionEnum:
793  analyses_temp[numanalyses++]=DamageEvolutionAnalysisEnum;
794  break;
795 
796  case TransientSolutionEnum:{
797  /*We have multiple analyses here, process one by one*/
798  bool isSIA,isFS,isthermal,isenthalpy,ismasstransport,isgroundingline,isstressbalance,ismovingfront,ishydrology,isdamage,issmb,isslr,isesa,isgia;
799  iomodel->FindConstant(&isthermal,"md.transient.isthermal");
800  iomodel->FindConstant(&ismovingfront,"md.transient.ismovingfront");
801  iomodel->FindConstant(&ismasstransport,"md.transient.ismasstransport");
802  iomodel->FindConstant(&isstressbalance,"md.transient.isstressbalance");
803  iomodel->FindConstant(&isgroundingline,"md.transient.isgroundingline");
804  iomodel->FindConstant(&isdamage,"md.transient.isdamageevolution");
805  iomodel->FindConstant(&ishydrology,"md.transient.ishydrology");
806  iomodel->FindConstant(&issmb,"md.transient.issmb");
807  iomodel->FindConstant(&isslr,"md.transient.isslr");
808  iomodel->FindConstant(&isesa,"md.transient.isesa");
809  iomodel->FindConstant(&isgia,"md.transient.isgia");
810  int* analyses_iter = NULL;
811  int num_analyses_iter = 0;
812  if(isstressbalance){
813  SolutionAnalysesList(&analyses_iter,&num_analyses_iter,iomodel,StressbalanceSolutionEnum);
814  xMemCpy<int>(&analyses_temp[numanalyses],analyses_iter,num_analyses_iter);
815  numanalyses+=num_analyses_iter; xDelete<int>(analyses_iter);
816  }
817  if(isthermal && iomodel->domaintype==Domain3DEnum){
818  SolutionAnalysesList(&analyses_iter,&num_analyses_iter,iomodel,ThermalSolutionEnum);
819  xMemCpy<int>(&analyses_temp[numanalyses],analyses_iter,num_analyses_iter);
820  numanalyses+=num_analyses_iter; xDelete<int>(analyses_iter);
821  }
822  if(ismasstransport || isgroundingline){
823  analyses_temp[numanalyses++]=MasstransportAnalysisEnum;
824  int basalforcing_model;
825  iomodel->FindConstant(&basalforcing_model,"md.basalforcings.model");
826  if(basalforcing_model==BasalforcingsPicoEnum){
827  bool isplume;
828  iomodel->FindConstant(&isplume,"md.basalforcings.isplume");
829  if(isplume){
830  analyses_temp[numanalyses++]=GLheightadvectionAnalysisEnum;
831  }
832  }
833  }
834  if(issmb) analyses_temp[numanalyses++]=SmbAnalysisEnum;
835  if(ismovingfront){
836  analyses_temp[numanalyses++]=ExtrapolationAnalysisEnum;
837  analyses_temp[numanalyses++]=LevelsetAnalysisEnum;
838  }
839  if(ishydrology){
840  SolutionAnalysesList(&analyses_iter,&num_analyses_iter,iomodel,HydrologySolutionEnum);
841  xMemCpy<int>(&analyses_temp[numanalyses],analyses_iter,num_analyses_iter);
842  numanalyses+=num_analyses_iter; xDelete<int>(analyses_iter);
843  }
844  if(isdamage){
845  analyses_temp[numanalyses++]=DamageEvolutionAnalysisEnum;
846  }
847  if(isslr){
848  analyses_temp[numanalyses++]=GiaAnalysisEnum;
849  analyses_temp[numanalyses++]=SealevelriseAnalysisEnum;
850  }
851  if(isesa){
852  analyses_temp[numanalyses++]=EsaAnalysisEnum;
853  }
854  if(isgia){
855  analyses_temp[numanalyses++]=GiaAnalysisEnum;
856  }
857 
858  if(iomodel->domaintype==Domain2DverticalEnum || iomodel->domaintype==Domain3DEnum){
859  analyses_temp[numanalyses++]=ExtrudeFromBaseAnalysisEnum;
860  analyses_temp[numanalyses++]=ExtrudeFromTopAnalysisEnum;
861  analyses_temp[numanalyses++]=FreeSurfaceBaseAnalysisEnum;
862  analyses_temp[numanalyses++]=FreeSurfaceTopAnalysisEnum;
863  }
864  analyses_temp[numanalyses++]=L2ProjectionBaseAnalysisEnum;
865  }
866  break;
867 
868  default:
869  _error_("solution type: " << EnumToStringx(solutiontype) << " not supported yet!");
870  break;
871  }
872 
873  /*Copy analyses from temp to output*/
874  _assert_(numanalyses<MAXANALYSES);
875  analyses=xNew<int>(numanalyses);
876  for(int i=0;i<numanalyses;i++) analyses[i]=analyses_temp[i];
877 
878  /*Assign output pointers:*/
879  if(pnumanalyses) *pnumanalyses=numanalyses;
880  if(panalyses) *panalyses=analyses;
881  else xDelete<int>(analyses);
882 }/*}}}*/

◆ Solve()

void FemModel::Solve ( void  )

Definition at line 883 of file FemModel.cpp.

883  {/*{{{*/
884 
885  /*profiling: */
886  bool profiling = false;
887  IssmDouble solution_time;
888  IssmDouble solution_flops;
889  IssmDouble solution_memory;
890 
891  /*solution: */
892  int solution_type;
893  void (*solutioncore)(FemModel*)=NULL; //core solution function pointer
894 
895  _printf0_("call computational core:\n");
896 
897  /*Retrieve solution_type from parameters: */
898  parameters->FindParam(&solution_type,SolutionTypeEnum);
899 
900  /*Figure out which solution core we are going to run with the current solution type: */
901  WrapperCorePointerFromSolutionEnum(&solutioncore,this->parameters,solution_type);
902 
903  /*run solution core: */
904  profiler->Start(CORE);
905  solutioncore(this);
906  profiler->Stop(CORE);
907 
908  /*run AD core if needed: */
909  profiler->Start(ADCORE);
910  ad_core(this);
911  profiler->Stop(ADCORE);
912 
913  /*some profiling results for the core: */
914  parameters->FindParam(&profiling,DebugProfilingEnum);
915  if(profiling){
916 
917  solution_time=profiler->TotalTime(CORE);
918  solution_flops=profiler->TotalFlops(CORE);
919  solution_memory=profiler->Memory(CORE);
920 
921  _printf0_("\nCore solution profiling\n");
922  _printf0_(" elapsed time : " << solution_time << " Seconds\n");
923  _printf0_(" number of flops : " << solution_flops << " Flops\n");
924  _printf0_(" memory used : " << solution_memory << " Bytes\n");
925 
926  /*Individual cores*/
927  _printf0_("Individual core profiling\n");
928  if(profiler->Used(THERMALCORE)) _printf0_(" "<<setw(40)<<left<<"Thermal core elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(THERMALCORE) << " sec\n");
929  if(profiler->Used(HYDROLOGYCORE)) _printf0_(" "<<setw(40)<<left<<"Hydrology core elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(HYDROLOGYCORE) << " sec\n");
930  if(profiler->Used(STRESSBALANCECORE)) _printf0_(" "<<setw(40)<<left<<"Stress balance core elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(STRESSBALANCECORE) << " sec\n");
931  if(profiler->Used(DAMAGECORE)) _printf0_(" "<<setw(40)<<left<<"Damage core elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(DAMAGECORE) << " sec\n");
932  if(profiler->Used(MOVINGFRONTCORE)) _printf0_(" "<<setw(40)<<left<<"Moving front core elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(MOVINGFRONTCORE) << " sec\n");
933  if(profiler->Used(MASSTRANSPORTCORE)) _printf0_(" "<<setw(40)<<left<<"Mass transport core elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(MASSTRANSPORTCORE) << " sec\n");
934  if(profiler->Used(SMBCORE)) _printf0_(" "<<setw(40)<<left<<"SMB core elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(SMBCORE) << " sec\n");
935  if(profiler->Used(GROUNDINGLINECORE)) _printf0_(" "<<setw(40)<<left<<"Groundingline migration core elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(GROUNDINGLINECORE) << " sec\n");
936  if(profiler->Used(GIACORE)) _printf0_(" "<<setw(40)<<left<<"GIA core elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(GIACORE) << " sec\n");
937  if(profiler->Used(ESACORE)) _printf0_(" "<<setw(40)<<left<<"ESA core elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(ESACORE) << " sec\n");
938  if(profiler->Used(SLRCORE)) _printf0_(" "<<setw(40)<<left<<"SLR core elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(SLRCORE) << " sec\n");
939  if(profiler->Used(MPISERIAL)) _printf0_(" "<<setw(40)<<left<<"MPISERIAL elapsed time:"<<setw(7)<<setprecision(6)<<profiler->TotalTime(MPISERIAL) << " sec\n");
940 
941  /*Add to results: */
942  results->AddObject(new GenericExternalResult<IssmDouble>(results->Size()+1, ProfilingSolutionTimeEnum, solution_time));
943  results->AddObject(new GenericExternalResult<IssmDouble>(results->Size()+1, ProfilingCurrentMemEnum, solution_memory));
944  results->AddObject(new GenericExternalResult<IssmDouble>(results->Size()+1, ProfilingCurrentFlopsEnum, solution_flops));
945 
946  #ifdef _HAVE_AD_
947  solution_time = profiler->TotalTime(ADCORE);
948  solution_flops = profiler->TotalFlops(ADCORE);
949  solution_memory = profiler->Memory(ADCORE);
950 
951  _printf0_("AD profiling\n");
952  _printf0_(" elapsed time : " << solution_time << " Seconds\n");
953  _printf0_(" number of flops : " << solution_flops << " Flops\n");
954  _printf0_(" memory used : " << solution_memory << " Bytes\n");
955  #endif
956  _printf0_("\n");
957  }
958 }

◆ BalancethicknessMisfitx()

void FemModel::BalancethicknessMisfitx ( IssmDouble *  pV)

Definition at line 962 of file FemModel.cpp.

962  {/*{{{*/
963 
964  /*output: */
965  IssmDouble J=0.;
966  IssmDouble J_sum;
967 
968  IssmDouble weight,vx,vy,H,dvx[2],dvy[2],dH[2];
969  IssmDouble temp,Jdet,dhdt,groundedice_melting,surface_mass_balance;
970  IssmDouble* xyz_list = NULL;
971  IssmDouble dp[3];
972 
973  /*Compute Misfit: */
974  for(int i=0;i<elements->Size();i++){
975  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
976 
977  /*If on water, return 0: */
978  if(!element->IsIceInElement()) continue;
979 
980  /* Get node coordinates*/
981  element->GetVerticesCoordinates(&xyz_list);
982  DatasetInput2* weights_input = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
983  Input2* thickness_input = element->GetInput2(ThicknessEnum); _assert_(thickness_input);
984  Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
985  Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
986  Input2* surface_mass_balance_input = element->GetInput2(SmbMassBalanceEnum); _assert_(surface_mass_balance_input);
987  Input2* groundedice_melting_input = element->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedice_melting_input);
988  Input2* dhdt_input = element->GetInput2(BalancethicknessThickeningRateEnum); _assert_(dhdt_input);
989 
990  /* Start looping on the number of gaussian points: */
991  Gauss* gauss=element->NewGauss(2);
992  for(int ig=gauss->begin();ig<gauss->end();ig++){
993 
994  gauss->GaussPoint(ig);
995 
996  /* Get Jacobian determinant: */
997  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
998 
999  /*Get all parameters at gaussian point*/
1000  weights_input->GetInputValue(&weight,gauss,BalancethicknessMisfitEnum);
1001  thickness_input->GetInputValue(&H, gauss);
1002  thickness_input->GetInputDerivativeValue(&dH[0],xyz_list,gauss);
1003  surface_mass_balance_input->GetInputValue(&surface_mass_balance,gauss);
1004  groundedice_melting_input->GetInputValue(&groundedice_melting,gauss);
1005  dhdt_input->GetInputValue(&dhdt,gauss);
1006  vx_input->GetInputValue(&vx,gauss);
1007  vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
1008  vy_input->GetInputValue(&vy,gauss);
1009  vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
1010 
1011  /*Balance thickness soft constraint J = 1/2 (div(Hv)-a)^2*/
1012  temp = vx*dH[0]+vy*dH[1]+H*(dvx[0]+dvy[1]) - (surface_mass_balance-groundedice_melting-dhdt);
1013  J +=weight*1/2*temp*temp*Jdet*gauss->weight;
1014  }
1015 
1016  /*clean up and Return: */
1017  xDelete<IssmDouble>(xyz_list);
1018  delete gauss;
1019  }
1020 
1021  /*Sum all J from all cpus of the cluster:*/
1022  ISSM_MPI_Reduce (&J,&J_sum,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
1023  ISSM_MPI_Bcast(&J_sum,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1024  J=J_sum;
1025 
1026  /*Assign output pointers: */
1027  *presponse=J;
1028 
1029 }/*}}}*/

◆ CalvingRateVonmisesx()

void FemModel::CalvingRateVonmisesx ( )

Definition at line 1030 of file FemModel.cpp.

1030  {/*{{{*/
1031 
1032  for(int i=0;i<elements->Size();i++){
1033  Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
1034  element->CalvingRateVonmises();
1035  }
1036 }

◆ CalvingRateLevermannx()

void FemModel::CalvingRateLevermannx ( )

Definition at line 1038 of file FemModel.cpp.

1038  {/*{{{*/
1039 
1040  for(int i=0;i<elements->Size();i++){
1041  Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
1042  element->CalvingRateLevermann();
1043  }
1044 }

◆ CalvingFluxLevelsetx()

void FemModel::CalvingFluxLevelsetx ( )

Definition at line 1046 of file FemModel.cpp.

1046  {/*{{{*/
1047 
1048  for(int i=0;i<elements->Size();i++){
1049  Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
1050  element->CalvingFluxLevelset();
1051  }
1052 }

◆ CalvingMeltingFluxLevelsetx()

void FemModel::CalvingMeltingFluxLevelsetx ( )

Definition at line 1054 of file FemModel.cpp.

1054  {/*{{{*/
1055 
1056  for(int i=0;i<elements->Size();i++){
1057  Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
1058  element->CalvingMeltingFluxLevelset();
1059  }
1060 }

◆ DeviatoricStressx()

void FemModel::DeviatoricStressx ( )

Definition at line 1095 of file FemModel.cpp.

1095  {/*{{{*/
1096 
1097  for(int i=0;i<elements->Size();i++){
1098  Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
1099  element->ComputeDeviatoricStressTensor();
1100  }
1101 }

◆ Divergencex()

void FemModel::Divergencex ( IssmDouble *  pdiv)

Definition at line 1227 of file FemModel.cpp.

1227  {/*{{{*/
1228 
1229  IssmDouble local_divergence=0;
1230  IssmDouble total_divergence;
1231 
1232  for(int i=0;i<this->elements->Size();i++){
1233  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1234  local_divergence+=element->Divergence();
1235  }
1236  ISSM_MPI_Reduce(&local_divergence,&total_divergence,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
1237  ISSM_MPI_Bcast(&total_divergence,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1238 
1239  /*Assign output pointers: */
1240  *pdiv=total_divergence;
1241 
1242 }/*}}}*/

◆ ElementOperationx()

void FemModel::ElementOperationx ( void(Element::*)(void)  function)

Definition at line 1243 of file FemModel.cpp.

1243  { /*{{{*/
1244 
1245  for(int i=0;i<elements->Size();i++){
1246  Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
1247  (element->*function)();
1248  }
1249 
1250 }

◆ ElementResponsex()

void FemModel::ElementResponsex ( IssmDouble *  presponse,
int  response_enum 
)

Definition at line 1252 of file FemModel.cpp.

1252  {/*{{{*/
1253 
1254  int found=0;
1255  int sumfound=0;
1256  int cpu_found=-1;
1257  int index;
1258  IssmDouble response;
1259  Element* element=NULL;
1260 
1261  /*retrieve element we are interested in: */
1262  this->parameters->FindParam(&index,IndexEnum);
1263  int my_rank=IssmComm::GetRank();
1264 
1265  /*now, go through our elements, and retrieve the one with this id: index: */
1266  for(int i=0;i<this->elements->Size();i++){
1267  element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1268  if (element->Id()==index){
1269  found=1;
1270  cpu_found=my_rank;
1271  break;
1272  }
1273  }
1274 
1275  /*Broadcast whether we found the element: */
1276  ISSM_MPI_Allreduce ( &found,&sumfound,1,ISSM_MPI_INT,ISSM_MPI_SUM,IssmComm::GetComm());
1277  if(!sumfound)_error_("could not find material with id" << index << " to compute ElementResponse");
1278 
1279  /*Ok, we found the element, compute responseocity: */
1280  if(my_rank==cpu_found){
1281  element->ElementResponse(&response,response_enum);
1282  }
1283 
1284  /*Broadcast and plug into response: */
1285  ISSM_MPI_Allreduce ( &cpu_found,&cpu_found,1,ISSM_MPI_INT,ISSM_MPI_MAX,IssmComm::GetComm());
1286  ISSM_MPI_Bcast(&response,1,ISSM_MPI_DOUBLE,cpu_found,IssmComm::GetComm());
1287 
1288  /*Assign output pointers: */
1289  *presponse=response;
1290 
1291 }/*}}}*/

◆ FloatingAreax()

void FemModel::FloatingAreax ( IssmDouble *  pV,
bool  scaled 
)

Definition at line 1292 of file FemModel.cpp.

1292  {/*{{{*/
1293 
1294  IssmDouble local_floating_area= 0;
1295  IssmDouble total_floating_area;
1296 
1297  for(int i=0;i<this->elements->Size();i++){
1298  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1299  local_floating_area+=element->FloatingArea(scaled);
1300  }
1301  ISSM_MPI_Reduce(&local_floating_area,&total_floating_area,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
1302  ISSM_MPI_Bcast(&total_floating_area,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1303 
1304  /*Assign output pointers: */
1305  *pV=total_floating_area;
1306 
1307 }/*}}}*/

◆ GetInputLocalMinMaxOnNodesx()

void FemModel::GetInputLocalMinMaxOnNodesx ( IssmDouble **  pmin,
IssmDouble **  pmax,
IssmDouble *  ug 
)

Definition at line 1308 of file FemModel.cpp.

1308  {/*{{{*/
1309 
1310  /*Initialize output vectors*/
1311  int numnodes = this->nodes->NumberOfNodes();
1312  IssmDouble* uLmin_local = xNew<IssmDouble>(numnodes);
1313  IssmDouble* uLmax_local = xNew<IssmDouble>(numnodes);
1314  IssmDouble* uLmin = xNew<IssmDouble>(numnodes);
1315  IssmDouble* uLmax = xNew<IssmDouble>(numnodes);
1316  for(int i=0;i<numnodes;i++){
1317  uLmin_local[i] = +1.e+50;
1318  uLmax_local[i] = -1.e+50;
1319  }
1320 
1321  for(int i=0;i<this->elements->Size();i++){
1322  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1323  element->GetInputLocalMinMaxOnNodes(uLmin_local,uLmax_local,ug);
1324  }
1325 
1326  /*Synchronize all CPUs*/
1327  ISSM_MPI_Allreduce((void*)uLmin_local,(void*)uLmin,numnodes,ISSM_MPI_DOUBLE,ISSM_MPI_MIN,IssmComm::GetComm());
1328  ISSM_MPI_Allreduce((void*)uLmax_local,(void*)uLmax,numnodes,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,IssmComm::GetComm());
1329  xDelete<IssmDouble>(uLmin_local);
1330  xDelete<IssmDouble>(uLmax_local);
1331 
1332  /*Assign output pointers: */
1333  *pmin=uLmin;
1334  *pmax=uLmax;
1335 
1336 }/*}}}*/

◆ GetLocalVectorWithClonesGset()

void FemModel::GetLocalVectorWithClonesGset ( IssmDouble **  plocal_ug,
Vector< IssmDouble > *  ug 
)

Definition at line 1337 of file FemModel.cpp.

1337  {/*{{{*/
1338 
1339  this->nodes->GetLocalVectorWithClonesGset(plocal_ug,ug);
1340 
1341 }/*}}}*/

◆ GetLocalVectorWithClonesVertices()

void FemModel::GetLocalVectorWithClonesVertices ( IssmDouble **  plocal_vector,
Vector< IssmDouble > *  vector 
)

Definition at line 1342 of file FemModel.cpp.

1342  {/*{{{*/
1343 
1344  /*retrieve vertex info*/
1345  int localsize = this->vertices->NumberOfVerticesLocalAll();
1346  int localsize_masters = this->vertices->NumberOfVerticesLocal();
1347 
1348  /*Get local vector of vector*/
1349  int *indices_vector_masters = NULL;
1350  IssmDouble *local_vector_masters = NULL;
1351  vector->GetLocalVector(&local_vector_masters,&indices_vector_masters);
1352  _assert_(localsize_masters==indices_vector_masters[localsize_masters-1] - indices_vector_masters[0]+1);
1353  xDelete<int>(indices_vector_masters);
1354 
1355  /*Now, extend vectors to account for clones (make vectors longer, for clones at the end)*/
1356  IssmDouble *local_vector = xNew<IssmDouble>(localsize);
1357  xMemCpy<IssmDouble>(local_vector,local_vector_masters,localsize_masters);
1358  xDelete<IssmDouble>(local_vector_masters);
1359 
1360  /*Now send and receive vector for vertices on partition edge*/
1361  SyncLocalVectorWithClonesVertices(local_vector);
1362 
1363  /*Assign output pointer*/
1364  *plocal_vector = local_vector;
1365 }/*}}}*/

◆ SyncLocalVectorWithClonesVertices()

void FemModel::SyncLocalVectorWithClonesVertices ( IssmDouble *  local_vector)

Definition at line 1366 of file FemModel.cpp.

1366  {/*{{{*/
1367 
1368  /*recover my_rank:*/
1369  ISSM_MPI_Status status;
1370  int my_rank = IssmComm::GetRank();
1371  int num_procs = IssmComm::GetSize();
1372 
1373  /*Now send and receive vector for vertices on partition edge*/
1374  #ifdef _HAVE_AD_
1375  IssmDouble* buffer = xNew<IssmDouble>(this->vertices->Size(),"t"); //only one alloc, "t" is required by adolc
1376  #else
1377  IssmDouble* buffer = xNew<IssmDouble>(this->vertices->Size());
1378  #endif
1379  for(int rank=0;rank<num_procs;rank++){
1380  if(this->vertices->common_send[rank]){
1381  int numids = this->vertices->common_send[rank];
1382  for(int i=0;i<numids;i++){
1383  int master_lid = this->vertices->common_send_ids[rank][i];
1384  Vertex* vertex=xDynamicCast<Vertex*>(this->vertices->GetObjectByOffset(master_lid));
1385  _assert_(!vertex->clone);
1386  buffer[i] = local_vector[vertex->lid];
1387  }
1388  ISSM_MPI_Send(buffer,numids,ISSM_MPI_DOUBLE,rank,0,IssmComm::GetComm());
1389  }
1390  }
1391  for(int rank=0;rank<num_procs;rank++){
1392  if(this->vertices->common_recv[rank]){
1393  int numids = this->vertices->common_recv[rank];
1394  ISSM_MPI_Recv(buffer,numids,ISSM_MPI_DOUBLE,rank,0,IssmComm::GetComm(),&status);
1395  for(int i=0;i<numids;i++){
1396  int master_lid = this->vertices->common_recv_ids[rank][i];
1397  Vertex* vertex=xDynamicCast<Vertex*>(this->vertices->GetObjectByOffset(master_lid));
1398  _assert_(vertex->clone);
1399  local_vector[vertex->lid] = buffer[i];
1400  }
1401  }
1402  }
1403  xDelete<IssmDouble>(buffer);
1404 }/*}}}*/

◆ SyncLocalVectorWithClonesVerticesAdd()

void FemModel::SyncLocalVectorWithClonesVerticesAdd ( IssmDouble *  local_vector)

Definition at line 1405 of file FemModel.cpp.

1405  {/*{{{*/
1406 
1407  /*recover my_rank:*/
1408  ISSM_MPI_Status status;
1409  int my_rank = IssmComm::GetRank();
1410  int num_procs = IssmComm::GetSize();
1411 
1412  /*Now send and receive vector for vertices on partition edge*/
1413  #ifdef _HAVE_AD_
1414  IssmDouble* buffer = xNew<IssmDouble>(this->vertices->Size(),"t"); //only one alloc, "t" is required by adolc
1415  #else
1416  IssmDouble* buffer = xNew<IssmDouble>(this->vertices->Size());
1417  #endif
1418 
1419  /*1st: add slaves to master values (reverse of what we usually do)*/
1420  for(int rank=0;rank<num_procs;rank++){
1421  if(this->vertices->common_recv[rank]){
1422  int numids = this->vertices->common_recv[rank];
1423  for(int i=0;i<numids;i++){
1424  int master_lid = this->vertices->common_recv_ids[rank][i];
1425  Vertex* vertex=xDynamicCast<Vertex*>(this->vertices->GetObjectByOffset(master_lid));
1426  _assert_(vertex->clone);
1427  buffer[i] = local_vector[vertex->lid];
1428  }
1429  ISSM_MPI_Send(buffer,numids,ISSM_MPI_DOUBLE,rank,0,IssmComm::GetComm());
1430  }
1431  }
1432  for(int rank=0;rank<num_procs;rank++){
1433  if(this->vertices->common_send[rank]){
1434  int numids = this->vertices->common_send[rank];
1435  ISSM_MPI_Recv(buffer,numids,ISSM_MPI_DOUBLE,rank,0,IssmComm::GetComm(),&status);
1436  for(int i=0;i<numids;i++){
1437  int master_lid = this->vertices->common_send_ids[rank][i];
1438  Vertex* vertex=xDynamicCast<Vertex*>(this->vertices->GetObjectByOffset(master_lid));
1439  _assert_(!vertex->clone);
1440  local_vector[vertex->lid] += buffer[i];
1441  }
1442  }
1443  }
1444 
1445  /*Now sync masters across partitions*/
1446  for(int rank=0;rank<num_procs;rank++){
1447  if(this->vertices->common_send[rank]){
1448  int numids = this->vertices->common_send[rank];
1449  for(int i=0;i<numids;i++){
1450  int master_lid = this->vertices->common_send_ids[rank][i];
1451  Vertex* vertex=xDynamicCast<Vertex*>(this->vertices->GetObjectByOffset(master_lid));
1452  _assert_(!vertex->clone);
1453  buffer[i] = local_vector[vertex->lid];
1454  }
1455  ISSM_MPI_Send(buffer,numids,ISSM_MPI_DOUBLE,rank,0,IssmComm::GetComm());
1456  }
1457  }
1458  for(int rank=0;rank<num_procs;rank++){
1459  if(this->vertices->common_recv[rank]){
1460  int numids = this->vertices->common_recv[rank];
1461  ISSM_MPI_Recv(buffer,numids,ISSM_MPI_DOUBLE,rank,0,IssmComm::GetComm(),&status);
1462  for(int i=0;i<numids;i++){
1463  int master_lid = this->vertices->common_recv_ids[rank][i];
1464  Vertex* vertex=xDynamicCast<Vertex*>(this->vertices->GetObjectByOffset(master_lid));
1465  _assert_(vertex->clone);
1466  local_vector[vertex->lid] = buffer[i];
1467  }
1468  }
1469  }
1470  xDelete<IssmDouble>(buffer);
1471 }/*}}}*/

◆ GetLocalVectorWithClonesNodes()

void FemModel::GetLocalVectorWithClonesNodes ( IssmDouble **  plocal_vector,
Vector< IssmDouble > *  vector 
)

Definition at line 1472 of file FemModel.cpp.

1472  {/*{{{*/
1473 
1474  /*recover my_rank:*/
1475  ISSM_MPI_Status status;
1476  int my_rank = IssmComm::GetRank();
1477  int num_procs = IssmComm::GetSize();
1478 
1479  /*retrieve vertex info*/
1480  int localsize = this->nodes->NumberOfNodesLocalAll();
1481  int localsize_masters = this->nodes->NumberOfNodesLocal();
1482 
1483  /*Get local vector of vector*/
1484  int *indices_vector_masters = NULL;
1485  IssmDouble *local_vector_masters = NULL;
1486  vector->GetLocalVector(&local_vector_masters,&indices_vector_masters);
1487  _assert_(localsize_masters==indices_vector_masters[localsize_masters-1] - indices_vector_masters[0]+1);
1488  xDelete<int>(indices_vector_masters);
1489 
1490  /*Now, extend vectors to account for clones (make vectors longer, for clones at the end)*/
1491  IssmDouble *local_vector = xNew<IssmDouble>(localsize);
1492  xMemCpy<IssmDouble>(local_vector,local_vector_masters,localsize_masters);
1493  xDelete<IssmDouble>(local_vector_masters);
1494 
1495  /*Now send and receive vector for nodes on partition edge*/
1496  #ifdef _HAVE_AD_
1497  IssmDouble* buffer = xNew<IssmDouble>(this->nodes->Size(),"t"); //only one alloc, "t" is required by adolc
1498  #else
1499  IssmDouble* buffer = xNew<IssmDouble>(this->nodes->Size());
1500  #endif
1501  for(int rank=0;rank<num_procs;rank++){
1502  if(this->nodes->common_send[rank]){
1503  int numids = this->nodes->common_send[rank];
1504  for(int i=0;i<numids;i++){
1505  int master_lid = this->nodes->common_send_ids[rank][i];
1506  Node* vertex=xDynamicCast<Node*>(this->nodes->GetObjectByOffset(master_lid));
1507  _assert_(!vertex->clone);
1508  buffer[i] = local_vector[vertex->lid];
1509  }
1510  ISSM_MPI_Send(buffer,numids,ISSM_MPI_DOUBLE,rank,0,IssmComm::GetComm());
1511  }
1512  }
1513  for(int rank=0;rank<num_procs;rank++){
1514  if(this->nodes->common_recv[rank]){
1515  int numids = this->nodes->common_recv[rank];
1516  ISSM_MPI_Recv(buffer,numids,ISSM_MPI_DOUBLE,rank,0,IssmComm::GetComm(),&status);
1517  for(int i=0;i<numids;i++){
1518  int master_lid = this->nodes->common_recv_ids[rank][i];
1519  Node* vertex=xDynamicCast<Node*>(this->nodes->GetObjectByOffset(master_lid));
1520  _assert_(vertex->clone);
1521  local_vector[vertex->lid] = buffer[i];
1522  }
1523  }
1524  }
1525  xDelete<IssmDouble>(buffer);
1526 
1527  /*Assign output pointer*/
1528  *plocal_vector = local_vector;
1529 }/*}}}*/

◆ GroundedAreax()

void FemModel::GroundedAreax ( IssmDouble *  pV,
bool  scaled 
)

Definition at line 1530 of file FemModel.cpp.

1530  {/*{{{*/
1531 
1532  IssmDouble local_grounded_area= 0;
1533  IssmDouble total_grounded_area;
1534 
1535  for(int i=0;i<this->elements->Size();i++){
1536  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1537  local_grounded_area+=element->GroundedArea(scaled);
1538  }
1539  ISSM_MPI_Reduce(&local_grounded_area,&total_grounded_area,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
1540  ISSM_MPI_Bcast(&total_grounded_area,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1541 
1542  /*Assign output pointers: */
1543  *pV=total_grounded_area;
1544 
1545 }/*}}}*/

◆ IcefrontAreax()

void FemModel::IcefrontAreax ( )

Definition at line 1546 of file FemModel.cpp.

1546  {/*{{{*/
1547 
1548  int numvertices = 6;
1549  int numbasins;
1550  IssmDouble* BasinId = xNew<IssmDouble>(numvertices);
1551  this->parameters->FindParam(&numbasins,FrontalForcingsNumberofBasinsEnum);
1552  IssmDouble* basin_icefront_area = xNewZeroInit<IssmDouble>(numbasins);
1553 
1554  for(int basin=1;basin<numbasins+1;basin++){
1555  IssmDouble local_icefront_area = 0;
1556  IssmDouble total_icefront_area;
1557 
1558  for(int i=0;i<this->elements->Size();i++){
1559  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1560  element->GetInputListOnVertices(BasinId,FrontalForcingsBasinIdEnum);
1561  for(int j=0;j<numvertices;j++){
1562  if(BasinId[j]==basin){
1563  local_icefront_area+=element->GetIcefrontArea();
1564  break;
1565  }
1566  }
1567  }
1568  ISSM_MPI_Reduce(&local_icefront_area,&total_icefront_area,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm());
1569  ISSM_MPI_Bcast(&total_icefront_area,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1570 
1571  basin_icefront_area[basin-1]=total_icefront_area;
1572  }
1573 
1574  this->parameters->AddObject(new DoubleVecParam(FrontalForcingsBasinIcefrontAreaEnum,basin_icefront_area,numbasins));
1575 
1576  xDelete<IssmDouble>(basin_icefront_area);
1577  xDelete<IssmDouble>(BasinId);
1578 }/*}}}*/

◆ IcefrontMassFluxx()

void FemModel::IcefrontMassFluxx ( IssmDouble *  presponse,
bool  scaled 
)

Definition at line 1579 of file FemModel.cpp.

1579  {/*{{{*/
1580 
1581  IssmDouble local_mass_flux = 0;
1582  IssmDouble total_mass_flux;
1583 
1584  for(int i=0;i<this->elements->Size();i++){
1585  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1586  local_mass_flux+=element->IcefrontMassFlux(scaled);
1587  }
1588  ISSM_MPI_Reduce(&local_mass_flux,&total_mass_flux,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
1589  ISSM_MPI_Bcast(&total_mass_flux,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1590 
1591  /*Assign output pointers: */
1592  *pM=total_mass_flux;
1593 
1594 }/*}}}*/

◆ IcefrontMassFluxLevelsetx()

void FemModel::IcefrontMassFluxLevelsetx ( IssmDouble *  presponse,
bool  scaled 
)

Definition at line 1595 of file FemModel.cpp.

1595  {/*{{{*/
1596 
1597  IssmDouble local_mass_flux = 0;
1598  IssmDouble total_mass_flux;
1599 
1600  for(int i=0;i<this->elements->Size();i++){
1601  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1602  local_mass_flux+=element->IcefrontMassFluxLevelset(scaled);
1603  }
1604  ISSM_MPI_Reduce(&local_mass_flux,&total_mass_flux,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
1605  ISSM_MPI_Bcast(&total_mass_flux,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1606 
1607  /*Assign output pointers: */
1608  *pM=total_mass_flux;
1609 
1610 }/*}}}*/

◆ GroundinglineMassFluxx()

void FemModel::GroundinglineMassFluxx ( IssmDouble *  presponse,
bool  scaled 
)

Definition at line 1627 of file FemModel.cpp.

1627  {/*{{{*/
1628 
1629  /*First we need to depth average the velocities*/
1630  int domaintype;
1631  this->parameters->FindParam(&domaintype,DomainTypeEnum);
1632  this->parameters->SetParam(VxEnum,InputToDepthaverageInEnum);
1633  this->parameters->SetParam(VxAverageEnum,InputToDepthaverageOutEnum);
1634  depthaverage_core(this);
1635  if(domaintype!=Domain2DverticalEnum){
1636  this->parameters->SetParam(VyEnum,InputToDepthaverageInEnum);
1637  this->parameters->SetParam(VyAverageEnum,InputToDepthaverageOutEnum);
1638  depthaverage_core(this);
1639  }
1640 
1641  IssmDouble local_mass_flux = 0;
1642  IssmDouble total_mass_flux;
1643 
1644  for(int i=0;i<this->elements->Size();i++){
1645  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1646  local_mass_flux+=element->GroundinglineMassFlux(scaled);
1647  }
1648  ISSM_MPI_Reduce(&local_mass_flux,&total_mass_flux,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
1649  ISSM_MPI_Bcast(&total_mass_flux,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1650 
1651  /*Assign output pointers: */
1652  *pM=total_mass_flux;
1653 
1654 }/*}}}*/

◆ IceMassx()

void FemModel::IceMassx ( IssmDouble *  pV,
bool  scaled 
)

Definition at line 1655 of file FemModel.cpp.

1655  {/*{{{*/
1656 
1657  IssmDouble local_ice_mass = 0;
1658  IssmDouble total_ice_mass;
1659 
1660  for(int i=0;i<this->elements->Size();i++){
1661  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1662  local_ice_mass+=element->IceMass(scaled);
1663  }
1664  ISSM_MPI_Reduce(&local_ice_mass,&total_ice_mass,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
1665  ISSM_MPI_Bcast(&total_ice_mass,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1666 
1667  /*Assign output pointers: */
1668  *pM=total_ice_mass;
1669 
1670 }/*}}}*/

◆ IceVolumex()

void FemModel::IceVolumex ( IssmDouble *  pV,
bool  scaled 
)

Definition at line 1687 of file FemModel.cpp.

1687  {/*{{{*/
1688 
1689  IssmDouble local_ice_volume = 0;
1690  IssmDouble total_ice_volume;
1691 
1692  for(int i=0;i<this->elements->Size();i++){
1693  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1694  local_ice_volume+=element->IceVolume(scaled);
1695  }
1696  ISSM_MPI_Reduce(&local_ice_volume,&total_ice_volume,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
1697  ISSM_MPI_Bcast(&total_ice_volume,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1698 
1699  /*Assign output pointers: */
1700  *pV=total_ice_volume;
1701 
1702 }/*}}}*/

◆ IceVolumeAboveFloatationx()

void FemModel::IceVolumeAboveFloatationx ( IssmDouble *  pV,
bool  scaled 
)

Definition at line 1671 of file FemModel.cpp.

1671  {/*{{{*/
1672 
1673  IssmDouble local_ice_volume_af = 0;
1674  IssmDouble total_ice_volume_af;
1675 
1676  for(int i=0;i<this->elements->Size();i++){
1677  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1678  local_ice_volume_af+=element->IceVolumeAboveFloatation(scaled);
1679  }
1680  ISSM_MPI_Reduce(&local_ice_volume_af,&total_ice_volume_af,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
1681  ISSM_MPI_Bcast(&total_ice_volume_af,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1682 
1683  /*Assign output pointers: */
1684  *pV=total_ice_volume_af;
1685 
1686 }/*}}}*/

◆ InputMakeDiscontinuous()

void FemModel::InputMakeDiscontinuous ( int  enum_in)

Definition at line 1611 of file FemModel.cpp.

1611  {/*{{{*/
1612 
1613  int numvertices = 6;
1614  IssmDouble* P1DGlist = xNew<IssmDouble>(numvertices);
1615 
1616  for(int i=0;i<this->elements->Size();i++){
1617  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1618  element->GetInputListOnVertices(P1DGlist,enum_in);
1619  element->AddInput2(DummyEnum,P1DGlist,P1DGEnum);
1620  }
1621  xDelete<IssmDouble>(P1DGlist);
1622 
1623  this->inputs2->ChangeEnum(DummyEnum,enum_in);
1624  this->inputs2->DeleteInput(DummyEnum);
1625 
1626 }/*}}}*/

◆ MassFluxx()

void FemModel::MassFluxx ( IssmDouble *  presponse)

Definition at line 1703 of file FemModel.cpp.

1703  {/*{{{*/
1704 
1705  int i,j;
1706  Element *element = NULL;
1707  int element_id;
1708  bool ispresent = false;
1709  IssmDouble mass_flux = 0;
1710  IssmDouble all_mass_flux = 0;
1711  int counter;
1712  IssmDouble **array = NULL;
1713  int M;
1714  int *mdims_array = NULL;
1715  int *ndims_array = NULL;
1716  IssmDouble *segments = NULL;
1717  int num_segments;
1718 
1719  /*First, figure out which segment to compute our mass flux on. Start with retrieving qmu_mass_flux_segments: */
1720  this->parameters->FindParam(&ispresent,MassFluxSegmentsPresentEnum);
1721  if(!ispresent)_error_("no mass flux segments available!");
1722  this->parameters->FindParam(&array,&M,&mdims_array,&ndims_array,MassFluxSegmentsEnum);
1723 
1724  /*Retrieve index of segments being used for MassFlux computation: */
1725  parameters->FindParam(&counter,IndexEnum);
1726 
1727  /*retrieve segments from array: */
1728  segments = array[counter-1]; //matlab to "C" indexing
1729  num_segments = mdims_array[counter-1];
1730 
1731  /*Go through segments, and then elements, and figure out which elements belong to a segment.
1732  * When we find one, use the element to compute the mass flux on the segment: */
1733  for(i=0;i<num_segments;i++){
1734  element_id=reCast<int,IssmDouble>(*(segments+5*i+4));
1735  for(j=0;j<elements->Size();j++){
1736  element=(Element*)this->elements->GetObjectByOffset(j);
1737  if (element->Id()==element_id){
1738  /*We found the element which owns this segment, use it to compute the mass flux: */
1739  mass_flux+=element->MassFlux(segments+5*i+0);
1740  break;
1741  }
1742  }
1743  }
1744 
1745  ISSM_MPI_Allreduce ( (void*)&mass_flux,(void*)&all_mass_flux,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,IssmComm::GetComm());
1746  mass_flux=all_mass_flux;
1747 
1748  /*Free ressources:*/
1749  for(i=0;i<M;i++){
1750  IssmDouble* matrix=array[i];
1751  xDelete<IssmDouble>(matrix);
1752  }
1753  xDelete<int>(mdims_array);
1754  xDelete<int>(ndims_array);
1755  xDelete<IssmDouble*>(array);
1756 
1757  /*Assign output pointers: */
1758  *pmass_flux=mass_flux;
1759 
1760 }/*}}}*/

◆ MaxAbsVxx()

void FemModel::MaxAbsVxx ( IssmDouble *  presponse)

Definition at line 1761 of file FemModel.cpp.

1761  {/*{{{*/
1762 
1763  int i;
1764  IssmDouble maxabsvx;
1765  IssmDouble node_maxabsvx;
1766  IssmDouble element_maxabsvx;
1767 
1768  /*Go through elements, and request velocity: */
1769  maxabsvx=-INFINITY;
1770  for(i=0;i<this->elements->Size();i++){
1771  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1772  Input2* input = element->GetInput2(VxEnum);
1773  element_maxabsvx=input->GetInputMaxAbs();
1774  if(element_maxabsvx>maxabsvx) maxabsvx=element_maxabsvx;
1775  }
1776 
1777  /*Figure out maximum across the cluster: */
1778  ISSM_MPI_Reduce(&maxabsvx,&node_maxabsvx,1,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,0,IssmComm::GetComm() );
1779  ISSM_MPI_Bcast(&node_maxabsvx,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1780  maxabsvx=node_maxabsvx;
1781 
1782  /*Assign output pointers:*/
1783  *pmaxabsvx=maxabsvx;
1784 
1785 }/*}}}*/

◆ MaxAbsVyx()

void FemModel::MaxAbsVyx ( IssmDouble *  presponse)

Definition at line 1786 of file FemModel.cpp.

1786  {/*{{{*/
1787 
1788  int i;
1789  IssmDouble maxabsvy;
1790  IssmDouble node_maxabsvy;
1791  IssmDouble element_maxabsvy;
1792 
1793  /*Go through elements, and request velocity: */
1794  maxabsvy=-INFINITY;
1795  for(i=0;i<this->elements->Size();i++){
1796  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1797  Input2* input = element->GetInput2(VyEnum);
1798  element_maxabsvy=input->GetInputMaxAbs();
1799  if(element_maxabsvy>maxabsvy) maxabsvy=element_maxabsvy;
1800  }
1801 
1802  /*Figure out maximum across the cluster: */
1803  ISSM_MPI_Reduce(&maxabsvy,&node_maxabsvy,1,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,0,IssmComm::GetComm() );
1804  ISSM_MPI_Bcast(&node_maxabsvy,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1805  maxabsvy=node_maxabsvy;
1806 
1807  /*Assign output pointers:*/
1808  *pmaxabsvy=maxabsvy;
1809 
1810 }/*}}}*/

◆ MaxAbsVzx()

void FemModel::MaxAbsVzx ( IssmDouble *  presponse)

Definition at line 1811 of file FemModel.cpp.

1811  {/*{{{*/
1812 
1813  int i;
1814  IssmDouble maxabsvz;
1815  IssmDouble node_maxabsvz;
1816  IssmDouble element_maxabsvz;
1817 
1818  /*Go through elements, and request velocity: */
1819  maxabsvz=-INFINITY;
1820  for(i=0;i<this->elements->Size();i++){
1821  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1822  Input2* input = element->GetInput2(VzEnum);
1823  element_maxabsvz=input->GetInputMaxAbs();
1824  if(element_maxabsvz>maxabsvz) maxabsvz=element_maxabsvz;
1825  }
1826 
1827  /*Figure out maximum across the cluster: */
1828  ISSM_MPI_Reduce(&maxabsvz,&node_maxabsvz,1,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,0,IssmComm::GetComm() );
1829  ISSM_MPI_Bcast(&node_maxabsvz,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1830  maxabsvz=node_maxabsvz;
1831 
1832  /*Assign output pointers:*/
1833  *pmaxabsvz=maxabsvz;
1834 
1835 }/*}}}*/

◆ MaxDivergencex()

void FemModel::MaxDivergencex ( IssmDouble *  pdiv)

Definition at line 1836 of file FemModel.cpp.

1836  {/*{{{*/
1837 
1838  IssmDouble local_divergence;
1839  IssmDouble node_max_divergence;
1840  IssmDouble max_divergence = -INFINITY;
1841 
1842  for(int i=0;i<this->elements->Size();i++){
1843  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1844  local_divergence=element->Divergence();
1845  if(fabs(local_divergence)>max_divergence) max_divergence=fabs(local_divergence);
1846  }
1847  ISSM_MPI_Reduce(&max_divergence,&node_max_divergence,1,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,0,IssmComm::GetComm() );
1848  ISSM_MPI_Bcast(&node_max_divergence,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1849  max_divergence=node_max_divergence;
1850 
1851  /*Assign output pointers: */
1852  *pdiv=max_divergence;
1853 
1854 }/*}}}*/

◆ MaxVelx()

void FemModel::MaxVelx ( IssmDouble *  presponse)

Definition at line 1855 of file FemModel.cpp.

1855  {/*{{{*/
1856 
1857  int i;
1858  IssmDouble maxvel;
1859  IssmDouble node_maxvel;
1860  IssmDouble element_maxvel;
1861 
1862  /*Go through elements, and request velocity: */
1863  maxvel=-INFINITY;
1864  for(i=0;i<this->elements->Size();i++){
1865  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1866  Input2* vel_input = element->GetInput2(VelEnum); _assert_(vel_input);
1867  element_maxvel = vel_input->GetInputMax();
1868  if(element_maxvel>maxvel) maxvel=element_maxvel;
1869  }
1870 
1871  /*Figure out maximum across the cluster: */
1872  ISSM_MPI_Reduce(&maxvel,&node_maxvel,1,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,0,IssmComm::GetComm() );
1873  ISSM_MPI_Bcast(&node_maxvel,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1874  maxvel=node_maxvel;
1875 
1876  /*Assign output pointers:*/
1877  *pmaxvel=maxvel;
1878 
1879 }/*}}}*/

◆ MaxVxx()

void FemModel::MaxVxx ( IssmDouble *  presponse)

Definition at line 1880 of file FemModel.cpp.

1880  {/*{{{*/
1881 
1882  int i;
1883  IssmDouble maxvx;
1884  IssmDouble node_maxvx;
1885  IssmDouble element_maxvx;
1886 
1887  /*Go through elements, and request velocity: */
1888  maxvx=-INFINITY;
1889  for(i=0;i<this->elements->Size();i++){
1890  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1891  Input2* vx_input = element->GetInput2(VxEnum); _assert_(vx_input);
1892  element_maxvx = vx_input->GetInputMax();
1893  if(element_maxvx>maxvx) maxvx=element_maxvx;
1894  }
1895 
1896  /*Figure out maximum across the cluster: */
1897  ISSM_MPI_Reduce(&maxvx,&node_maxvx,1,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,0,IssmComm::GetComm() );
1898  ISSM_MPI_Bcast(&node_maxvx,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1899  maxvx=node_maxvx;
1900 
1901  /*Assign output pointers:*/
1902  *pmaxvx=maxvx;
1903 
1904 }/*}}}*/

◆ MaxVyx()

void FemModel::MaxVyx ( IssmDouble *  presponse)

Definition at line 1905 of file FemModel.cpp.

1905  {/*{{{*/
1906 
1907  int i;
1908  IssmDouble maxvy;
1909  IssmDouble node_maxvy;
1910  IssmDouble element_maxvy;
1911 
1912  /*Go through elements, and request velocity: */
1913  maxvy=-INFINITY;
1914  for(i=0;i<this->elements->Size();i++){
1915  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1916  Input2* vy_input = element->GetInput2(VyEnum); _assert_(vy_input);
1917  element_maxvy = vy_input->GetInputMax();
1918  if(element_maxvy>maxvy) maxvy=element_maxvy;
1919  }
1920 
1921  /*Figure out maximum across the cluster: */
1922  ISSM_MPI_Reduce(&maxvy,&node_maxvy,1,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,0,IssmComm::GetComm() );
1923  ISSM_MPI_Bcast(&node_maxvy,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1924  maxvy=node_maxvy;
1925 
1926  /*Assign output pointers:*/
1927  *pmaxvy=maxvy;
1928 
1929 }/*}}}*/

◆ MaxVzx()

void FemModel::MaxVzx ( IssmDouble *  presponse)

Definition at line 1930 of file FemModel.cpp.

1930  {/*{{{*/
1931 
1932  int i;
1933  IssmDouble maxvz;
1934  IssmDouble node_maxvz;
1935  IssmDouble element_maxvz;
1936 
1937  /*Go through elements, and request velocity: */
1938  maxvz=-INFINITY;
1939  for(i=0;i<this->elements->Size();i++){
1940  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1941  Input2* vz_input = element->GetInput2(VzEnum); _assert_(vz_input);
1942  element_maxvz = vz_input->GetInputMax();
1943  if(element_maxvz>maxvz) maxvz=element_maxvz;
1944  }
1945 
1946  /*Figure out maximum across the cluster: */
1947  ISSM_MPI_Reduce(&maxvz,&node_maxvz,1,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,0,IssmComm::GetComm() );
1948  ISSM_MPI_Bcast(&node_maxvz,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1949  maxvz=node_maxvz;
1950 
1951  /*Assign output pointers:*/
1952  *pmaxvz=maxvz;
1953 
1954 }/*}}}*/

◆ MinVelx()

void FemModel::MinVelx ( IssmDouble *  presponse)

Definition at line 1955 of file FemModel.cpp.

1955  {/*{{{*/
1956 
1957  int i;
1958  IssmDouble minvel;
1959  IssmDouble node_minvel;
1960  IssmDouble element_minvel;
1961 
1962  /*Go through elements, and request velocity: */
1963  minvel=INFINITY;
1964  for(i=0;i<this->elements->Size();i++){
1965  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1966  Input2* input = element->GetInput2(VelEnum);
1967  element_minvel =input->GetInputMin();
1968  if(element_minvel<minvel) minvel=element_minvel;
1969  }
1970 
1971  /*Figure out minimum across the cluster: */
1972  ISSM_MPI_Reduce(&minvel,&node_minvel,1,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,0,IssmComm::GetComm() );
1973  ISSM_MPI_Bcast(&node_minvel,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1974  minvel=node_minvel;
1975 
1976  /*Assign output pointers:*/
1977  *pminvel=minvel;
1978 
1979 }/*}}}*/

◆ MinVxx()

void FemModel::MinVxx ( IssmDouble *  presponse)

Definition at line 1980 of file FemModel.cpp.

1980  {/*{{{*/
1981 
1982  int i;
1983  IssmDouble minvx;
1984  IssmDouble node_minvx;
1985  IssmDouble element_minvx;
1986 
1987  /*Go through elements, and request velocity: */
1988  minvx=INFINITY;
1989  for(i=0;i<this->elements->Size();i++){
1990  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1991  Input2* input = element->GetInput2(VxEnum);
1992  element_minvx =input->GetInputMin();
1993  if(element_minvx<minvx) minvx=element_minvx;
1994  }
1995 
1996  /*Figure out minimum across the cluster: */
1997  ISSM_MPI_Reduce(&minvx,&node_minvx,1,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,0,IssmComm::GetComm() );
1998  ISSM_MPI_Bcast(&node_minvx,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
1999  minvx=node_minvx;
2000 
2001  /*Assign output pointers:*/
2002  *pminvx=minvx;
2003 
2004 }/*}}}*/

◆ MinVyx()

void FemModel::MinVyx ( IssmDouble *  presponse)

Definition at line 2005 of file FemModel.cpp.

2005  {/*{{{*/
2006 
2007  int i;
2008  IssmDouble minvy;
2009  IssmDouble node_minvy;
2010  IssmDouble element_minvy;
2011 
2012  /*Go through elements, and request velocity: */
2013  minvy=INFINITY;
2014  for(i=0;i<this->elements->Size();i++){
2015  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
2016  Input2* input = element->GetInput2(VyEnum);
2017  element_minvy =input->GetInputMin();
2018  if(element_minvy<minvy) minvy=element_minvy;
2019  }
2020 
2021  /*Figure out minimum across the cluster: */
2022  ISSM_MPI_Reduce(&minvy,&node_minvy,1,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,0,IssmComm::GetComm() );
2023  ISSM_MPI_Bcast(&node_minvy,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
2024  minvy=node_minvy;
2025 
2026  /*Assign output pointers:*/
2027  *pminvy=minvy;
2028 
2029 }/*}}}*/

◆ MinVzx()

void FemModel::MinVzx ( IssmDouble *  presponse)

Definition at line 2030 of file FemModel.cpp.

2030  {/*{{{*/
2031 
2032  int i;
2033  IssmDouble minvz;
2034  IssmDouble node_minvz;
2035  IssmDouble element_minvz;
2036 
2037  /*Go through elements, and request velocity: */
2038  minvz=INFINITY;
2039  for(i=0;i<this->elements->Size();i++){
2040  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
2041  Input2* input = element->GetInput2(VzEnum);
2042  element_minvz =input->GetInputMin();
2043  if(element_minvz<minvz) minvz=element_minvz;
2044  }
2045 
2046  /*Figure out minimum across the cluster: */
2047  ISSM_MPI_Reduce(&minvz,&node_minvz,1,ISSM_MPI_DOUBLE,ISSM_MPI_MAX,0,IssmComm::GetComm() );
2048  ISSM_MPI_Bcast(&node_minvz,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
2049  minvz=node_minvz;
2050 
2051  /*Assign output pointers:*/
2052  *pminvz=minvz;
2053 
2054 }/*}}}*/

◆ DistanceToFieldValue()

void FemModel::DistanceToFieldValue ( int  fieldenum,
IssmDouble  fieldvalue,
int  distanceenum 
)

Definition at line 1103 of file FemModel.cpp.

1103  {/*{{{*/
1104 
1105  /*recover my_rank:*/
1106  int my_rank = IssmComm::GetRank();
1107  int num_procs = IssmComm::GetSize();
1108 
1109  /*Get domain type (2d or 3d)*/
1110  int domaintype;
1111  this->parameters->FindParam(&domaintype,DomainTypeEnum);
1112 
1113  /*1: go throug all elements of this partition and figure out how many
1114  * segments we have (corresopnding to field = value)*/
1115  DataSet* segments=new DataSet();
1116  for(int i=0;i<elements->Size();i++){
1117  Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
1118  if(!element->IsOnBase()) continue;
1119  Element* basalelement = element->SpawnBasalElement();
1120  basalelement->WriteFieldIsovalueSegment(segments,fieldenum,fieldvalue);
1121  if(domaintype!=Domain2DhorizontalEnum){basalelement->DeleteMaterials(); delete basalelement;};
1122  }
1123 
1124  /*2: now get the segments from all partitions*/
1125  int segcount=segments->Size();
1126  int* allsegcount=xNew<int>(num_procs);
1127  ISSM_MPI_Gather(&segcount,1,ISSM_MPI_INT,allsegcount,1,ISSM_MPI_INT,0,IssmComm::GetComm());
1128  ISSM_MPI_Bcast(allsegcount,num_procs,ISSM_MPI_INT,0,IssmComm::GetComm());
1129 
1130  /* Every cpu should start its own dof count at the end of the dofcount from cpu-1*/
1131  int numseg_offset=0;
1132  int numseg=0;
1133  for(int i=0;i<my_rank; i++) numseg_offset+=allsegcount[i];
1134  for(int i=0;i<num_procs;i++) numseg+=allsegcount[i];
1135  IssmDouble* segmentlist = xNewZeroInit<IssmDouble>(4*numseg);
1136  IssmDouble* allsegmentlist = xNewZeroInit<IssmDouble>(4*numseg);
1137  for(int i=0;i<segments->Size();i++){
1138  Contour<IssmDouble>* segment=(Contour<IssmDouble>*)segments->GetObjectByOffset(i);
1139  _assert_(segment->nods == 2);
1140  segmentlist[(numseg_offset+i)*4 + 0] = segment->x[0];
1141  segmentlist[(numseg_offset+i)*4 + 1] = segment->y[0];
1142  segmentlist[(numseg_offset+i)*4 + 2] = segment->x[1];
1143  segmentlist[(numseg_offset+i)*4 + 3] = segment->y[1];
1144  }
1145 
1146  ISSM_MPI_Allreduce((void*)segmentlist,(void*)allsegmentlist,4*numseg,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,IssmComm::GetComm());
1147  delete segments;
1148  xDelete<IssmDouble>(segmentlist);
1149  xDelete<int>(allsegcount);
1150 
1151  /*3: Add distance input to all elements*/
1152  IssmDouble* distances = xNew<IssmDouble>(vertices->Size());
1153  IssmDouble d,xn,yn,dmin;
1154  int last = -1;
1155  for(int v=0;v<vertices->Size();v++){
1156 
1157  Vertex* vertex=dynamic_cast<Vertex*>(this->vertices->GetObjectByOffset(v));
1158  IssmDouble x = vertex->x;
1159  IssmDouble y = vertex->y;
1160 
1161  /*Most of the time the last checked segment is the closest so start with that one*/
1162  if(last>0){
1163  dmin = pow(allsegmentlist[4*last+0] - x,2) + pow(y-allsegmentlist[4*last+1],2);
1164  }
1165  else{
1166  dmin = 1.e+50;
1167  }
1168 
1169  for(int i=0;i<numseg;i++){
1170 
1171  /*Skip if tip is more than 10xdmin away*/
1172  if(pow(allsegmentlist[4*i+0] - x,2)>10*dmin) continue;
1173  if(pow(allsegmentlist[4*i+1] - y,2)>10*dmin) continue;
1174 
1175  IssmDouble l2 = (allsegmentlist[4*i+2]-allsegmentlist[4*i+0])*(allsegmentlist[4*i+2]-allsegmentlist[4*i+0]) + (allsegmentlist[4*i+3]-allsegmentlist[4*i+1])*(allsegmentlist[4*i+3]-allsegmentlist[4*i+1]);
1176 
1177  /*Segment has a length of 0*/
1178  if(l2==0.){
1179  d = (x-allsegmentlist[4*i+0])*(x-allsegmentlist[4*i+0])+(y-allsegmentlist[4*i+1])*(y-allsegmentlist[4*i+1]);
1180  if(d<dmin){
1181  dmin = d;
1182  last = i;
1183  }
1184  continue;
1185  }
1186 
1187  /*Consider the line extending the segment, parameterized as v + t (w - v).
1188  *We find projection of point p onto the line.
1189  *It falls where t = [(p-v) . (w-v)] / |w-v|^2*/
1190  IssmDouble t = ((x-allsegmentlist[4*i+0])*(allsegmentlist[4*i+2]-allsegmentlist[4*i+0]) + (y-allsegmentlist[4*i+1])*(allsegmentlist[4*i+3]-allsegmentlist[4*i+1]))/l2;
1191  if(t < 0.0){
1192  // Beyond the 'v' end of the segment
1193  d = (x-allsegmentlist[4*i+0])*(x-allsegmentlist[4*i+0])+(y-allsegmentlist[4*i+1])*(y-allsegmentlist[4*i+1]);
1194  }
1195  else if (t > 1.0){
1196  // Beyond the 'w' end of the segment
1197  d = (x-allsegmentlist[4*i+2])*(x-allsegmentlist[4*i+2])+(y-allsegmentlist[4*i+3])*(y-allsegmentlist[4*i+3]);
1198  }
1199  else{
1200  // Projection falls on the segment
1201  xn = allsegmentlist[4*i+0] + t * (allsegmentlist[4*i+2] - allsegmentlist[4*i+0]);
1202  yn = allsegmentlist[4*i+1] + t * (allsegmentlist[4*i+3] - allsegmentlist[4*i+1]);
1203  d = (x-xn)*(x-xn)+(y-yn)*(y-yn);
1204  }
1205 
1206  if(d<dmin){
1207  dmin = d;
1208  last = i;
1209  }
1210  }
1211 
1212  /*Update signed distance*/
1213  _assert_(vertex->lid<vertices->Size());
1214  distances[vertex->lid] = sqrt(dmin);
1215  }
1216 
1217  for(int i=0;i<this->elements->Size();i++){
1218  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
1219  element->CreateDistanceInputFromSegmentlist(distances,distanceenum);
1220  }
1221  //InputUpdateFromVectorx(this,distances,distanceenum,VertexLIdEnum);
1222 
1223  /*Clean up and return*/
1224  xDelete<IssmDouble>(distances);
1225  xDelete<IssmDouble>(allsegmentlist);
1226 }/*}}}*/

◆ ResetLevelset()

void FemModel::ResetLevelset ( void  )

Definition at line 2545 of file FemModel.cpp.

2545  {/*{{{*/
2546 
2547  this->DistanceToFieldValue(MaskIceLevelsetEnum,0.,MaskIceLevelsetEnum);
2548 
2549 }

◆ StrainRateparallelx()

void FemModel::StrainRateparallelx ( )

Definition at line 2630 of file FemModel.cpp.

2630  {/*{{{*/
2631 
2632  for(int i=0;i<elements->Size();i++){
2633  Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
2634  element->StrainRateparallel();
2635  }
2636 }

◆ StrainRateperpendicularx()

void FemModel::StrainRateperpendicularx ( )

Definition at line 2638 of file FemModel.cpp.

2638  {/*{{{*/
2639 
2640  for(int i=0;i<elements->Size();i++){
2641  Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
2642  element->StrainRateperpendicular();
2643  }
2644 }

◆ StrainRateeffectivex()

void FemModel::StrainRateeffectivex ( )

Definition at line 2646 of file FemModel.cpp.

2646  {/*{{{*/
2647 
2648  for(int i=0;i<elements->Size();i++){
2649  Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
2650  element->ComputeStrainRate();
2651  }
2652 }

◆ StressIntensityFactorx()

void FemModel::StressIntensityFactorx ( )

Definition at line 2654 of file FemModel.cpp.

2654  {/*{{{*/
2655 
2656  /*Update input for basal element only*/
2657  for(int i=0;i<elements->Size();i++){
2658  Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
2659  element->StressIntensityFactor();
2660  }
2661 }

◆ RignotMeltParameterizationx()

void FemModel::RignotMeltParameterizationx ( )

Definition at line 2622 of file FemModel.cpp.

2622  {/*{{{*/
2623 
2624  for(int i=0;i<elements->Size();i++){
2625  Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
2626  element->RignotMeltParameterization();
2627  }
2628 }

◆ TotalCalvingFluxLevelsetx()

void FemModel::TotalCalvingFluxLevelsetx ( IssmDouble *  pGbmb,
bool  scaled 
)

Definition at line 2929 of file FemModel.cpp.

2929  {/*{{{*/
2930 
2931  IssmDouble local_calving_flux = 0;
2932  IssmDouble total_calving_flux;
2933 
2934  for(int i=0;i<this->elements->Size();i++){
2935  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
2936  local_calving_flux+=element->TotalCalvingFluxLevelset(scaled);
2937  }
2938  ISSM_MPI_Reduce(&local_calving_flux,&total_calving_flux,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
2939  ISSM_MPI_Bcast(&total_calving_flux,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
2940 
2941  /*Assign output pointers: */
2942  *pM=total_calving_flux;
2943 
2944 }/*}}}*/

◆ TotalCalvingMeltingFluxLevelsetx()

void FemModel::TotalCalvingMeltingFluxLevelsetx ( IssmDouble *  pGbmb,
bool  scaled 
)

Definition at line 2945 of file FemModel.cpp.

2945  {/*{{{*/
2946 
2947  IssmDouble local_calving_flux = 0;
2948  IssmDouble total_calving_flux;
2949 
2950  for(int i=0;i<this->elements->Size();i++){
2951  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
2952  local_calving_flux+=element->TotalCalvingMeltingFluxLevelset(scaled);
2953  }
2954  ISSM_MPI_Reduce(&local_calving_flux,&total_calving_flux,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
2955  ISSM_MPI_Bcast(&total_calving_flux,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
2956 
2957  /*Assign output pointers: */
2958  *pM=total_calving_flux;
2959 
2960 }/*}}}*/

◆ TotalFloatingBmbx()

void FemModel::TotalFloatingBmbx ( IssmDouble *  pFbmb,
bool  scaled 
)

Definition at line 2961 of file FemModel.cpp.

2961  {/*{{{*/
2962 
2963  IssmDouble local_fbmb = 0;
2964  IssmDouble total_fbmb;
2965 
2966  for(int i=0;i<this->elements->Size();i++){
2967  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
2968  local_fbmb+=element->TotalFloatingBmb(scaled);
2969  }
2970  ISSM_MPI_Reduce(&local_fbmb,&total_fbmb,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
2971  ISSM_MPI_Bcast(&total_fbmb,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
2972 
2973  /*Assign output pointers: */
2974  *pFbmb=total_fbmb;
2975 
2976 }/*}}}*/

◆ TotalGroundedBmbx()

void FemModel::TotalGroundedBmbx ( IssmDouble *  pGbmb,
bool  scaled 
)

Definition at line 2977 of file FemModel.cpp.

2977  {/*{{{*/
2978 
2979  IssmDouble local_gbmb = 0;
2980  IssmDouble total_gbmb;
2981 
2982  for(int i=0;i<this->elements->Size();i++){
2983  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
2984  local_gbmb+=element->TotalGroundedBmb(scaled);
2985  }
2986  ISSM_MPI_Reduce(&local_gbmb,&total_gbmb,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
2987  ISSM_MPI_Bcast(&total_gbmb,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
2988 
2989  /*Assign output pointers: */
2990  *pGbmb=total_gbmb;
2991 
2992 }/*}}}*/

◆ TotalSmbx()

void FemModel::TotalSmbx ( IssmDouble *  pSmb,
bool  scaled 
)

Definition at line 2993 of file FemModel.cpp.

2993  {/*{{{*/
2994 
2995  IssmDouble local_smb = 0;
2996  IssmDouble total_smb;
2997 
2998  for(int i=0;i<this->elements->Size();i++){
2999  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
3000  local_smb+=element->TotalSmb(scaled);
3001  }
3002  ISSM_MPI_Reduce(&local_smb,&total_smb,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
3003  ISSM_MPI_Bcast(&total_smb,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
3004 
3005  /*Assign output pointers: */
3006  *pSmb=total_smb;
3007 
3008 }/*}}}*/

◆ CostFunctionx()

void FemModel::CostFunctionx ( IssmDouble *  pJ,
IssmDouble **  pJlist,
int *  pn 
)

Definition at line 1062 of file FemModel.cpp.

1062  {/*{{{*/
1063 
1064  /*Intermediary*/
1065  int num_responses;
1066  int *responses = NULL;
1067  Results *cost_functions = NULL;
1068 
1069  /*Recover parameters*/
1070  parameters->FindParam(&num_responses,InversionNumCostFunctionsEnum);
1071  parameters->FindParam(&responses,NULL,InversionCostFunctionsEnum);
1072 
1073  /*Get the value of all cost functions*/
1074  this->RequestedOutputsx(&cost_functions,responses,num_responses);
1075 
1076  /*Get and add all contributions one by one*/
1077  IssmDouble J=0;
1078  IssmDouble* Jlist = xNew<IssmDouble>(num_responses);
1079  for(int i=0;i<num_responses;i++){
1080  ExternalResult* result=(ExternalResult*)cost_functions->GetObjectByOffset(i);
1081  Jlist[i] = reCast<IssmDouble>(result->GetValue());
1082  J += Jlist[i];
1083  }
1084  _assert_(cost_functions->Size()==num_responses);
1085 
1086  /*Assign output pointers: */
1087  delete cost_functions;
1088  xDelete<int>(responses);
1089  if(pJ) *pJ = J;
1090  if(pJlist) *pJlist = Jlist;
1091  else xDelete<IssmDouble>(Jlist);
1092  if(pn) *pn = num_responses;
1093 }

◆ OutputControlsx()

void FemModel::OutputControlsx ( Results **  presults)

Definition at line 2171 of file FemModel.cpp.

2171  {/*{{{*/
2172 
2173  /*parameters: */
2174  int num_controls,step;
2175  IssmDouble time;
2176  int *control_type = NULL;
2177 
2178  /*recover results*/
2179  Results* results = *presults;
2180  if(!results) results = new Results();
2181 
2182  /*Get list of Controls*/
2183  this->parameters->FindParam(&num_controls,InversionNumControlParametersEnum);
2184  this->parameters->FindParam(&control_type,NULL,InversionControlParametersEnum);
2185  this->parameters->FindParam(&step,StepEnum);
2186  this->parameters->FindParam(&time,TimeEnum);
2187 
2188  for(int i=0;i<num_controls;i++){
2189 
2190  int control_enum = control_type[i];
2191  int gradient_enum;
2192 
2193  switch(i){
2194  case 0: gradient_enum = Gradient1Enum; break;
2195  case 1: gradient_enum = Gradient2Enum; break;
2196  case 2: gradient_enum = Gradient3Enum; break;
2197  default: _error_("more than 3 controls not implemented yet");
2198  }
2199 
2200  /*Allocate vector*/
2201  Vector<IssmPDouble> *vector_control = new Vector<IssmPDouble>(this->vertices->NumberOfVertices());
2202  Vector<IssmPDouble> *vector_gradient = new Vector<IssmPDouble>(this->vertices->NumberOfVertices());
2203 
2204  /*Fill in vector*/
2205  for(int j=0;j<elements->Size();j++){
2206  Element* element=(Element*)elements->GetObjectByOffset(j);
2207  element->ControlToVectors(vector_control,vector_gradient,control_enum);
2208  }
2209  vector_control->Assemble();
2210  vector_gradient->Assemble();
2211 
2212  results->AddResult(new GenericExternalResult<Vector<IssmPDouble>*>(results->Size()+1,control_enum,vector_control ,step,time));
2213  results->AddResult(new GenericExternalResult<Vector<IssmPDouble>*>(results->Size()+1,gradient_enum,vector_gradient,step,time));
2214  }
2215 
2216  /*Clean up and return*/
2217  xDelete<int>(control_type);
2218 }

◆ RequestedDependentsx()

void FemModel::RequestedDependentsx ( void  )

Definition at line 2220 of file FemModel.cpp.

2220  {/*{{{*/
2221 
2222  bool isautodiff = false;
2223  IssmDouble output_value;
2224 
2225  int num_dependents;
2226  IssmPDouble *dependents;
2227  DataSet* dependent_objects=NULL;
2228  int my_rank=IssmComm::GetRank();
2229 
2230  /*AD mode on?: */
2231  parameters->FindParam(&isautodiff,AutodiffIsautodiffEnum);
2232 
2233  if(isautodiff){
2234  #ifdef _HAVE_AD_
2235  parameters->FindParam(&num_dependents,AutodiffNumDependentsEnum);
2236  parameters->FindParam(&dependent_objects,AutodiffDependentObjectsEnum);
2237  if(num_dependents){
2238  dependents=xNew<IssmPDouble>(num_dependents);
2239 
2240  #if defined(_HAVE_CODIPACK_)
2241  auto& tape_codi = IssmDouble::getGlobalTape();
2242  #endif
2243 
2244  /*Go through our dependent variables, and compute the response:*/
2245  for(int i=0;i<dependent_objects->Size();i++){
2246  DependentObject* dep=(DependentObject*)dependent_objects->GetObjectByOffset(i);
2247  dep->Responsex(&output_value,this);
2248  if (my_rank==0) {
2249  #if defined(_HAVE_CODIPACK_)
2250  tape_codi.registerOutput(output_value);
2251  dependents[i] = output_value.getValue();
2252  codi_global.output_indices.push_back(output_value.getGradientData());
2253  #else
2254  output_value>>=dependents[i];
2255  #endif
2256  }
2257  }
2258  }
2259  delete dependent_objects;
2260  if(num_dependents)xDelete<IssmPDouble>(dependents);
2261  #else
2262  _error_("Should not be requesting dependents when an AD library is not available!");
2263  #endif
2264  }
2265 }

◆ RequestedOutputsx() [1/2]

void FemModel::RequestedOutputsx ( Results **  presults,
char **  requested_outputs,
int  numoutputs,
bool  save_results = true 
)

Definition at line 2267 of file FemModel.cpp.

2267  {/*{{{*/
2268 
2269  /*Intermediaries*/
2270  bool isvec,results_on_nodes;
2271  int step,output_enum,numonnodes;
2272  IssmDouble time;
2273  IssmDouble double_result;
2274  const char *output_string = NULL;
2275  char** resultsonnodes = NULL;
2276 
2277  /*recover results*/
2278  Results* results = *presults;
2279  if(!results) results = new Results();
2280 
2281  /*Get time and step*/
2282  parameters->FindParam(&step,StepEnum);
2283  parameters->FindParam(&time,TimeEnum);
2284  parameters->FindParam(&numonnodes,SettingsNumResultsOnNodesEnum);
2285  if(numonnodes) parameters->FindParam(&resultsonnodes,&numonnodes,SettingsResultsOnNodesEnum);
2286 
2287 
2288  /*Go through all requested output*/
2289  for(int i=0;i<numoutputs;i++){
2290  output_string = requested_outputs[i];
2291  output_enum = StringToEnumx(output_string,false);
2292  isvec = false;
2293 
2294 
2295  /*If string is not an enum, it is defined in output definitions*/
2296  if(output_enum<0){
2297  double_result = OutputDefinitionsResponsex(this,output_string);
2298  if(save_results){
2299  results->AddResult(new GenericExternalResult<IssmPDouble>(results->Size()+1,output_string,reCast<IssmPDouble>(double_result),step,time));
2300  continue;
2301  }
2302  }
2303  else{
2304  /*last chance for the output definition, if the enum is one of Outputdefinition[1-10]Enum:*/
2305  if(output_enum>=Outputdefinition1Enum && output_enum <=Outputdefinition100Enum){
2306  double_result = OutputDefinitionsResponsex(this,output_enum);
2307  if(save_results){
2308  results->AddResult(new GenericExternalResult<IssmPDouble>(results->Size()+1,output_string,reCast<IssmPDouble>(double_result),step,time));
2309  continue;
2310  }
2311  }
2312  else{
2313  switch(output_enum){
2314 
2315  /*Scalar output*/
2316  case DivergenceEnum: this->Divergencex(&double_result); break;
2317  case MaxDivergenceEnum: this->MaxDivergencex(&double_result); break;
2318  case IceMassEnum: this->IceMassx(&double_result,false); break;
2319  case IcefrontMassFluxEnum: this->IcefrontMassFluxx(&double_result,false); break;
2320  case IcefrontMassFluxLevelsetEnum: this->IcefrontMassFluxLevelsetx(&double_result,false); break;
2321  case IceMassScaledEnum: this->IceMassx(&double_result,true); break;
2322  case IceVolumeEnum: this->IceVolumex(&double_result,false); break;
2323  case IceVolumeScaledEnum: this->IceVolumex(&double_result,true); break;
2324  case IceVolumeAboveFloatationEnum: this->IceVolumeAboveFloatationx(&double_result,false); break;
2325  case IceVolumeAboveFloatationScaledEnum: this->IceVolumeAboveFloatationx(&double_result,true); break;
2326  case GroundedAreaEnum: this->GroundedAreax(&double_result,false); break;
2327  case GroundedAreaScaledEnum: this->GroundedAreax(&double_result,true); break;
2328  case GroundinglineMassFluxEnum: this->GroundinglineMassFluxx(&double_result,false); break;
2329  case FloatingAreaEnum: this->FloatingAreax(&double_result,false); break;
2330  case FloatingAreaScaledEnum: this->FloatingAreax(&double_result,true); break;
2331  case MinVelEnum: this->MinVelx(&double_result); break;
2332  case MaxVelEnum: this->MaxVelx(&double_result); break;
2333  case MinVxEnum: this->MinVxx(&double_result); break;
2334  case MaxVxEnum: this->MaxVxx(&double_result); break;
2335  case MaxAbsVxEnum: this->MaxAbsVxx(&double_result); break;
2336  case MinVyEnum: this->MinVyx(&double_result); break;
2337  case MaxVyEnum: this->MaxVyx(&double_result); break;
2338  case MaxAbsVyEnum: this->MaxAbsVyx(&double_result); break;
2339  case MinVzEnum: this->MinVzx(&double_result); break;
2340  case MaxVzEnum: this->MaxVzx(&double_result); break;
2341  case MaxAbsVzEnum: this->MaxAbsVzx(&double_result); break;
2342  case MassFluxEnum: this->MassFluxx(&double_result); break;
2343  case TotalCalvingFluxLevelsetEnum: this->TotalCalvingFluxLevelsetx(&double_result,false); break;
2344  case TotalCalvingMeltingFluxLevelsetEnum:this->TotalCalvingMeltingFluxLevelsetx(&double_result,false); break;
2345  case TotalFloatingBmbEnum: this->TotalFloatingBmbx(&double_result,false); break;
2346  case TotalFloatingBmbScaledEnum: this->TotalFloatingBmbx(&double_result,true); break;
2347  case TotalGroundedBmbEnum: this->TotalGroundedBmbx(&double_result,false); break;
2348  case TotalGroundedBmbScaledEnum: this->TotalGroundedBmbx(&double_result,true); break;
2349  case TotalSmbEnum: this->TotalSmbx(&double_result,false); break;
2350  case TotalSmbScaledEnum: this->TotalSmbx(&double_result,true); break;
2351 
2352  /*Scalar control output*/
2353  case SurfaceAbsVelMisfitEnum: SurfaceAbsVelMisfitx(&double_result,elements,nodes,vertices,loads,materials,parameters); break;
2354  case SurfaceRelVelMisfitEnum: SurfaceRelVelMisfitx(&double_result,elements,nodes,vertices,loads,materials,parameters); break;
2355  case SurfaceLogVelMisfitEnum: SurfaceLogVelMisfitx(&double_result,elements,nodes,vertices,loads,materials,parameters); break;
2356  case SurfaceLogVxVyMisfitEnum: SurfaceLogVxVyMisfitx(&double_result,elements,nodes,vertices,loads,materials,parameters); break;
2357  case SurfaceAverageVelMisfitEnum: SurfaceAverageVelMisfitx(&double_result,this); break;
2358  case ThicknessAbsMisfitEnum: ThicknessAbsMisfitx(&double_result,elements,nodes,vertices,loads,materials,parameters); break;
2359  case ThicknessAbsGradientEnum: this->ThicknessAbsGradientx(&double_result); break;
2360  case ThicknessAlongGradientEnum: ThicknessAlongGradientx(&double_result,elements,nodes,vertices,loads,materials,parameters); break;
2361  case ThicknessAcrossGradientEnum: ThicknessAcrossGradientx(&double_result,elements,nodes,vertices,loads,materials,parameters); break;
2362  case ThicknessPositiveEnum: this->ThicknessPositivex(&double_result); break;
2363  case RheologyBbarAbsGradientEnum: RheologyBbarAbsGradientx(&double_result,elements,nodes,vertices,loads,materials,parameters); break;
2364  case RheologyBAbsGradientEnum: RheologyBAbsGradientx(&double_result,elements,nodes,vertices,loads,materials,parameters); break;
2365  case RheologyBInitialguessMisfitEnum: RheologyBInitialguessMisfitx(&double_result,elements,nodes,vertices,loads,materials,parameters); break;
2366  case DragCoefficientAbsGradientEnum:DragCoefficientAbsGradientx(&double_result,elements,nodes,vertices,loads,materials,parameters); break;
2367  case BalancethicknessMisfitEnum: BalancethicknessMisfitx(&double_result); break;
2368  case SurfaceAbsMisfitEnum: SurfaceAbsMisfitx(&double_result); break;
2369  case OmegaAbsGradientEnum: OmegaAbsGradientx(&double_result); break;
2370  case EtaDiffEnum: EtaDiffx(&double_result); break;
2371 
2372  /*Vector special case (maybe should go to specific analysis?)*/
2373  case ChannelAreaEnum:{
2374 
2375  /*Get Number of Channels*/
2376  int numchannels_local=0,numchannels;
2377  for(int j=0;j<this->loads->Size();j++){
2378  if(this->loads->GetEnum(j)==ChannelEnum) numchannels_local++;
2379  }
2380  ISSM_MPI_Reduce(&numchannels_local,&numchannels,1,ISSM_MPI_INT,ISSM_MPI_SUM,0,IssmComm::GetComm() );
2381  ISSM_MPI_Bcast(&numchannels,1,ISSM_MPI_INT,0,IssmComm::GetComm());
2382 
2383  IssmPDouble* values = xNewZeroInit<IssmPDouble>(numchannels);
2384  IssmPDouble* allvalues = xNew<IssmPDouble>(numchannels);
2385 
2386  /*Fill-in vector*/
2387  for(int j=0;j<this->loads->Size();j++){
2388  if(this->loads->GetEnum(j)==ChannelEnum){
2389  Channel* channel=(Channel*)this->loads->GetObjectByOffset(j);
2390  channel->WriteChannelCrossSection(values);
2391  }
2392  }
2393 
2394  /*Gather from all cpus*/
2395  ISSM_MPI_Allreduce((void*)values,(void*)allvalues,numchannels,ISSM_MPI_PDOUBLE,ISSM_MPI_SUM,IssmComm::GetComm());
2396  xDelete<IssmPDouble>(values);
2397 
2398  if(save_results)results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,output_enum,allvalues,numchannels,1,step,time));
2399  xDelete<IssmPDouble>(allvalues);
2400 
2401  isvec = true;
2402  }
2403  break;
2404 
2405 
2406  /*Default is always Vector */
2407  default:
2408 
2409  /*Some preliminary calculation may be required (use similar syntax for other inputs)*/
2410  if(output_enum==NewDamageEnum){
2411  InputDuplicatex(this,DamageDEnum,DamageDOldEnum);
2412  InputDuplicatex(this,DamageDbarEnum,DamageDbarOldEnum);
2413  this->ElementOperationx(&Element::ComputeNewDamage);
2414  }
2415 
2416  /*Vector layout*/
2417  if(!IsInputEnum(output_enum)) _error_("Cannot output \""<<EnumToStringx(output_enum)<<"\" because it is not an input");
2418  int interpolation,nodesperelement,size,nlines,ncols,array_size;
2419  int rank_interpolation=-1,rank_nodesperelement=-1,rank_arraysize=-1,max_rank_arraysize=0;
2420  bool isarray=false;
2421 
2422  /*Get interpolation (and compute input if necessary)*/
2423  for(int j=0;j<elements->Size();j++){
2424  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(j));
2425  element->ResultInterpolation(&rank_interpolation,&rank_nodesperelement,&rank_arraysize,output_enum);
2426  if(rank_arraysize>max_rank_arraysize)max_rank_arraysize=rank_arraysize;
2427  }
2428  rank_arraysize=max_rank_arraysize;
2429 
2430  /*Broadcast for cpus that do not have any elements*/
2431  ISSM_MPI_Reduce(&rank_interpolation,&interpolation,1,ISSM_MPI_INT,ISSM_MPI_MAX,0,IssmComm::GetComm());
2432  ISSM_MPI_Reduce(&rank_nodesperelement,&nodesperelement,1,ISSM_MPI_INT,ISSM_MPI_MAX,0,IssmComm::GetComm());
2433  ISSM_MPI_Reduce(&rank_arraysize,&array_size,1,ISSM_MPI_INT,ISSM_MPI_MAX,0,IssmComm::GetComm());
2434  ISSM_MPI_Bcast(&interpolation,1,ISSM_MPI_INT,0,IssmComm::GetComm());
2435  ISSM_MPI_Bcast(&nodesperelement,1,ISSM_MPI_INT,0,IssmComm::GetComm());
2436  ISSM_MPI_Bcast(&array_size,1,ISSM_MPI_INT,0,IssmComm::GetComm());
2437 
2438  results_on_nodes=false;
2439  /*Loop to see if this output was requested on nodes*/
2440  for(int j=0;j<numonnodes & results_on_nodes==false;j++){
2441  if(strcmp(resultsonnodes[j],output_string) == 0 || strcmp(resultsonnodes[j],"all") == 0) results_on_nodes=true;
2442  }
2443 
2444  if(results_on_nodes){
2445 
2446  /*Allocate matrices*/
2447  int nbe = this->elements->NumberOfElements();
2448  IssmDouble* values = xNewZeroInit<IssmDouble>(nbe*nodesperelement);
2449  IssmDouble* allvalues = xNew<IssmDouble>(nbe*nodesperelement);
2450 
2451  /*Fill-in matrix*/
2452  for(int j=0;j<elements->Size();j++){
2453  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(j));
2454  element->ResultToPatch(values,nodesperelement,output_enum);
2455  }
2456 
2457  /*Gather from all cpus*/
2458  ISSM_MPI_Allreduce((void*)values,(void*)allvalues,nbe*nodesperelement,ISSM_MPI_PDOUBLE,ISSM_MPI_SUM,IssmComm::GetComm());
2459  xDelete<IssmDouble>(values);
2460 
2461  if(save_results)results->AddResult(new GenericExternalResult<IssmDouble*>(results->Size()+1,output_enum,allvalues,nbe,nodesperelement,step,time));
2462  xDelete<IssmDouble>(allvalues);
2463 
2464  }
2465  else{
2466 
2467  /*Allocate vector depending on interpolation*/
2468  switch(interpolation){
2469  case P0Enum: isarray = false; size = this->elements->NumberOfElements(); break;
2470  case P1Enum: isarray = false; size = this->vertices->NumberOfVertices(); break;
2471  case P0ArrayEnum: isarray = true; nlines = this->elements->NumberOfElements(); ncols= array_size; break;
2472  default: _error_("Interpolation "<<EnumToStringx(interpolation)<<" not supported yet");
2473 
2474  }
2475  if(!isarray){
2476  Vector<IssmDouble> *vector_result = new Vector<IssmDouble>(size);
2477 
2478  /*Fill in vector*/
2479  for(int j=0;j<elements->Size();j++){
2480  Element* element=(Element*)elements->GetObjectByOffset(j);
2481  element->ResultToVector(vector_result,output_enum);
2482  }
2483  vector_result->Assemble();
2484 
2485  if(save_results){
2486  results->AddResult(new GenericExternalResult<Vector<IssmDouble>*>(results->Size()+1,output_enum,vector_result,step,time));
2487  /*We do not do a copy for Vectors, so don't delete*/
2488  }
2489  else{
2490  delete vector_result;
2491  }
2492  }
2493  else{
2494  IssmDouble* values = xNewZeroInit<IssmDouble>(nlines*ncols);
2495  IssmDouble* allvalues = xNew<IssmDouble>(nlines*ncols);
2496 
2497  /*Fill-in matrix*/
2498  for(int j=0;j<elements->Size();j++){
2499  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(j));
2500  element->ResultToMatrix(values,ncols,output_enum);
2501  }
2502  /*Gather from all cpus*/
2503  ISSM_MPI_Allreduce((void*)values,(void*)allvalues,ncols*nlines,ISSM_MPI_PDOUBLE,ISSM_MPI_SUM,IssmComm::GetComm());
2504  xDelete<IssmDouble>(values);
2505 
2506  if(save_results)results->AddResult(new GenericExternalResult<IssmDouble*>(results->Size()+1,output_enum,allvalues,nlines,ncols,step,time));
2507  xDelete<IssmDouble>(allvalues);
2508  }
2509  }
2510  isvec = true;
2511  break;
2512  }
2513  }
2514 
2515  }
2516 
2517  /*Add result to Results*/
2518  if(!isvec && save_results){
2519  results->AddResult(new GenericExternalResult<IssmPDouble>(results->Size()+1,output_string,reCast<IssmPDouble>(double_result),step,time));
2520  }
2521  }
2522 
2523  /*Clean up*/
2524  for(int i=0;i<numonnodes;i++) xDelete<char>(resultsonnodes[i]);
2525  xDelete<char*>(resultsonnodes);
2526 
2527  /*Assign pointer and clean up*/
2528  *presults = results;
2529 }

◆ RequestedOutputsx() [2/2]

void FemModel::RequestedOutputsx ( Results **  presults,
int *  requested_outputs,
int  numoutputs,
bool  save_results = true 
)

Definition at line 2531 of file FemModel.cpp.

2531  {/*{{{*/
2532 
2533  /*Convert list of enums to list of string*/
2534  char** enumlist = xNew<char*>(numoutputs);
2535  for(int i=0;i<numoutputs;i++) EnumToStringx(&enumlist[i],requested_outputs[i]);
2536 
2537  /*Call main module*/
2538  this->RequestedOutputsx(presults,enumlist,numoutputs,save_results);
2539 
2540  /*clean up and return*/
2541  for(int i=0;i<numoutputs;i++) xDelete<char>(enumlist[i]);
2542  xDelete<char*>(enumlist);
2543 }

◆ Responsex() [1/2]

void FemModel::Responsex ( IssmDouble *  presponse,
int  response_descriptor_enum 
)

Definition at line 2558 of file FemModel.cpp.

2558  {/*{{{*/
2559 
2560  switch (response_descriptor_enum){
2561 
2562  case DivergenceEnum: this->Divergencex(responses); break;
2563  case MaxDivergenceEnum: this->MaxDivergencex(responses); break;
2564  case IceMassEnum: this->IceMassx(responses, false); break;
2565  case IceMassScaledEnum: this->IceMassx(responses, true); break;
2566  case IceVolumeEnum: this->IceVolumex(responses, false); break;
2567  case IceVolumeScaledEnum: this->IceVolumex(responses, true); break;
2568  case IceVolumeAboveFloatationEnum: this->IceVolumeAboveFloatationx(responses, false); break;
2569  case IceVolumeAboveFloatationScaledEnum: this->IceVolumeAboveFloatationx(responses, true); break;
2570  case IcefrontMassFluxEnum: this->IcefrontMassFluxx(responses, false); break;
2571  case IcefrontMassFluxLevelsetEnum: this->IcefrontMassFluxLevelsetx(responses, false); break;
2572  case GroundedAreaEnum: this->GroundedAreax(responses, false); break;
2573  case GroundedAreaScaledEnum: this->GroundedAreax(responses, true); break;
2574  case FloatingAreaEnum: this->FloatingAreax(responses, false); break;
2575  case FloatingAreaScaledEnum: this->FloatingAreax(responses, true); break;
2576  case MinVelEnum: this->MinVelx(responses); break;
2577  case MaxVelEnum: this->MaxVelx(responses); break;
2578  case MinVxEnum: this->MinVxx(responses); break;
2579  case MaxVxEnum: this->MaxVxx(responses); break;
2580  case MaxAbsVxEnum: this->MaxAbsVxx(responses); break;
2581  case MinVyEnum: this->MinVyx(responses); break;
2582  case MaxVyEnum: this->MaxVyx(responses); break;
2583  case MaxAbsVyEnum: this->MaxAbsVyx(responses); break;
2584  case MinVzEnum: this->MinVzx(responses); break;
2585  case MaxVzEnum: this->MaxVzx(responses); break;
2586  case MaxAbsVzEnum: this->MaxAbsVzx(responses); break;
2587  case MassFluxEnum: this->MassFluxx(responses); break;
2588  case SurfaceAbsVelMisfitEnum: SurfaceAbsVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
2589  case SurfaceRelVelMisfitEnum: SurfaceRelVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
2590  case SurfaceLogVelMisfitEnum: SurfaceLogVelMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
2591  case SurfaceLogVxVyMisfitEnum: SurfaceLogVxVyMisfitx(responses, elements,nodes, vertices, loads, materials,parameters); break;
2592  case SurfaceAverageVelMisfitEnum: SurfaceAverageVelMisfitx(responses,this); break;
2593  case ThicknessAbsMisfitEnum: ThicknessAbsMisfitx(responses, elements,nodes, vertices, loads, materials, parameters); break;
2594  case ThicknessAbsGradientEnum: this->ThicknessAbsGradientx(responses); break;
2595  case ThicknessAlongGradientEnum: ThicknessAlongGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
2596  case ThicknessAcrossGradientEnum: ThicknessAcrossGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
2597  case RheologyBbarAbsGradientEnum: RheologyBbarAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
2598  case DragCoefficientAbsGradientEnum: DragCoefficientAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break;
2599  case BalancethicknessMisfitEnum: BalancethicknessMisfitx(responses); break;
2600  case TotalCalvingFluxLevelsetEnum: this->TotalCalvingFluxLevelsetx(responses, false); break;
2601  case TotalCalvingMeltingFluxLevelsetEnum:this->TotalCalvingMeltingFluxLevelsetx(responses, false); break;
2602  case TotalFloatingBmbEnum: this->TotalFloatingBmbx(responses, false); break;
2603  case TotalFloatingBmbScaledEnum: this->TotalFloatingBmbx(responses, true); break;
2604  case TotalGroundedBmbEnum: this->TotalGroundedBmbx(responses, false); break;
2605  case TotalGroundedBmbScaledEnum: this->TotalGroundedBmbx(responses, true); break;
2606  case TotalSmbEnum: this->TotalSmbx(responses, false); break;
2607  case TotalSmbScaledEnum: this->TotalSmbx(responses, true); break;
2608  case MaterialsRheologyBbarEnum: this->ElementResponsex(responses,MaterialsRheologyBbarEnum); break;
2609  case VelEnum: this->ElementResponsex(responses,VelEnum); break;
2610  case FrictionCoefficientEnum: NodalValuex(responses, FrictionCoefficientEnum,elements,nodes, vertices, loads, materials, parameters); break;
2611  default:
2612  if(response_descriptor_enum>=Outputdefinition1Enum && response_descriptor_enum <=Outputdefinition100Enum){
2613  IssmDouble double_result = OutputDefinitionsResponsex(this,response_descriptor_enum);
2614  *responses=double_result;
2615  }
2616  else _error_("response descriptor \"" << EnumToStringx(response_descriptor_enum) << "\" not supported yet!");
2617  break;
2618  }
2619 
2620 }

◆ Responsex() [2/2]

void FemModel::Responsex ( IssmDouble *  presponse,
const char *  response_descriptor 
)

Definition at line 2551 of file FemModel.cpp.

2551  {/*{{{*/
2552 
2553  int response_descriptor_enum=StringToEnumx(response_descriptor);
2554  this->Responsex(responses, response_descriptor_enum);
2555 
2556 }

◆ SurfaceAbsMisfitx()

void FemModel::SurfaceAbsMisfitx ( IssmDouble *  pJ)

Definition at line 2663 of file FemModel.cpp.

2663  {/*{{{*/
2664 
2665  /*output: */
2666  IssmDouble J=0.;
2667  IssmDouble J_sum;
2668 
2669  IssmDouble surface,surfaceobs,weight;
2670  IssmDouble Jdet;
2671  IssmDouble* xyz_list = NULL;
2672 
2673  /*Compute Misfit: */
2674  for(int i=0;i<elements->Size();i++){
2675  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
2676 
2677  /*If on water, return 0: */
2678  if(!element->IsIceInElement()) continue;
2679 
2680  /* Get node coordinates*/
2681  element->GetVerticesCoordinates(&xyz_list);
2682 
2683  /*Retrieve all inputs we will be needing: */
2684  DatasetInput2* weights_input =element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
2685  Input2* surface_input =element->GetInput2(SurfaceEnum); _assert_(surface_input);
2686  Input2* surfaceobs_input=element->GetInput2(InversionSurfaceObsEnum); _assert_(surfaceobs_input);
2687 
2688  /* Start looping on the number of gaussian points: */
2689  Gauss* gauss=element->NewGauss(2);
2690  for(int ig=gauss->begin();ig<gauss->end();ig++){
2691 
2692  gauss->GaussPoint(ig);
2693 
2694  /* Get Jacobian determinant: */
2695  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
2696 
2697  /*Get all parameters at gaussian point*/
2698  weights_input->GetInputValue(&weight,gauss,SurfaceAbsMisfitEnum);
2699  surface_input->GetInputValue(&surface,gauss);
2700  surfaceobs_input->GetInputValue(&surfaceobs,gauss);
2701 
2702  /*Compute SurfaceAbsMisfitEnum*/
2703  J+=0.5*(surface-surfaceobs)*(surface-surfaceobs)*weight*Jdet*gauss->weight;
2704  }
2705  delete gauss;
2706  xDelete<IssmDouble>(xyz_list);
2707  }
2708 
2709  /*Sum all J from all cpus of the cluster:*/
2710  ISSM_MPI_Reduce (&J,&J_sum,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
2711  ISSM_MPI_Bcast(&J_sum,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
2712  J=J_sum;
2713 
2714  /*Assign output pointers: */
2715  *presponse=J;
2716 
2717 }/*}}}*/

◆ OmegaAbsGradientx()

void FemModel::OmegaAbsGradientx ( IssmDouble *  pJ)

Definition at line 2055 of file FemModel.cpp.

2055  {/*{{{*/
2056 
2057  /*output: */
2058  IssmDouble J=0.;
2059  IssmDouble J_sum;
2060 
2061  IssmDouble omega,weight;
2062  IssmDouble Jdet;
2063  IssmDouble* xyz_list = NULL;
2064  IssmDouble dp[3];
2065 
2066  /*Compute Misfit: */
2067  for(int i=0;i<elements->Size();i++){
2068  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
2069 
2070  /*If on water, return 0: */
2071  if(!element->IsIceInElement()) continue;
2072 
2073  /* Get node coordinates*/
2074  element->GetVerticesCoordinates(&xyz_list);
2075 
2076  /*Retrieve all inputs we will be needing: */
2077  DatasetInput2* weights_input = element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
2078  Input2* omega_input = element->GetInput2(BalancethicknessOmegaEnum); _assert_(omega_input);
2079 
2080  /* Start looping on the number of gaussian points: */
2081  Gauss* gauss=element->NewGauss(2);
2082  for(int ig=gauss->begin();ig<gauss->end();ig++){
2083 
2084  gauss->GaussPoint(ig);
2085 
2086  /* Get Jacobian determinant: */
2087  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
2088 
2089  /*Get all parameters at gaussian point*/
2090  weights_input->GetInputValue(&weight,gauss,OmegaAbsGradientEnum);
2091  omega_input->GetInputDerivativeValue(&dp[0],xyz_list,gauss);
2092 
2093  /*Tikhonov regularization: J = 1/2 ((dp/dx)^2 + (dp/dy)^2) */
2094  //J+=weight*1/2*(dp[0]*dp[0]+dp[1]*dp[1])*Jdet*gauss->weight;
2095  J+=weight*1/2*pow(dp[0]*dp[0]+dp[1]*dp[1],2)*Jdet*gauss->weight;
2096  }
2097 
2098  /*clean up and Return: */
2099  xDelete<IssmDouble>(xyz_list);
2100  delete gauss;
2101  }
2102 
2103  /*Sum all J from all cpus of the cluster:*/
2104  ISSM_MPI_Reduce (&J,&J_sum,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
2105  ISSM_MPI_Bcast(&J_sum,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
2106  J=J_sum;
2107 
2108  /*Assign output pointers: */
2109  *pJ=J;
2110 }

◆ EtaDiffx()

void FemModel::EtaDiffx ( IssmDouble *  pJ)

Definition at line 2112 of file FemModel.cpp.

2112  {/*{{{*/
2113 
2114  /*output: */
2115  IssmDouble J=0.;
2116  IssmDouble J_sum;
2117 
2118  IssmDouble omega,weight;
2119  IssmDouble Jdet;
2120  IssmDouble* xyz_list = NULL;
2121  IssmDouble p,p0;
2122 
2123  /*Compute Misfit: */
2124  for(int i=0;i<elements->Size();i++){
2125  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
2126 
2127  /*If on water, return 0: */
2128  if(!element->IsIceInElement()) continue;
2129 
2130  /* Get node coordinates*/
2131  element->GetVerticesCoordinates(&xyz_list);
2132 
2133  /*Retrieve all inputs we will be needing: */
2134  DatasetInput2* weights_input =element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
2135  Input2* omega_input =element->GetInput2(BalancethicknessOmegaEnum); _assert_(omega_input);
2136  Input2* omega0_input =element->GetInput2(BalancethicknessOmega0Enum); _assert_(omega0_input);
2137 
2138  /* Start looping on the number of gaussian points: */
2139  Gauss* gauss=element->NewGauss(2);
2140  for(int ig=gauss->begin();ig<gauss->end();ig++){
2141 
2142  gauss->GaussPoint(ig);
2143 
2144  /* Get Jacobian determinant: */
2145  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
2146 
2147  /*Get all parameters at gaussian point*/
2148  weights_input->GetInputValue(&weight,gauss,EtaDiffEnum);
2149  omega_input->GetInputValue(&p,gauss);
2150  omega0_input->GetInputValue(&p0,gauss);
2151 
2152  /*Tikhonov regularization: J = 1/2 ((dp/dx)^2 + (dp/dy)^2) */
2153  //J+=weight*1/2*(dp[0]*dp[0]+dp[1]*dp[1])*Jdet*gauss->weight;
2154  J+=weight*1/2*pow(p - p0,2)*Jdet*gauss->weight;
2155  }
2156 
2157  /*clean up and Return: */
2158  xDelete<IssmDouble>(xyz_list);
2159  delete gauss;
2160  }
2161 
2162  /*Sum all J from all cpus of the cluster:*/
2163  ISSM_MPI_Reduce (&J,&J_sum,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
2164  ISSM_MPI_Bcast(&J_sum,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
2165  J=J_sum;
2166 
2167  /*Assign output pointers: */
2168  *pJ=J;
2169 }

◆ ThicknessAverage()

void FemModel::ThicknessAverage ( )

Definition at line 2774 of file FemModel.cpp.

2774  {/*{{{*/
2775 
2776  int elementswidth = this->GetElementsWidth();//just 2D mesh, tria elements
2777  int numberofvertices = this->vertices->NumberOfVertices();//total number of vertices
2778 
2779  IssmDouble weight = 0.;
2780  IssmDouble* totalweight = NULL;
2781  IssmDouble* Hserial = NULL;
2782  IssmDouble* H = xNew<IssmDouble>(elementswidth);
2783  Vector<IssmDouble>* vecH = new Vector<IssmDouble>(numberofvertices);
2784  Vector<IssmDouble>* vectotalweight = new Vector<IssmDouble>(numberofvertices);
2785 
2786  for(int i=0;i<this->elements->Size();i++){
2787  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
2788 
2789  /*check if there is ice in this element*/
2790  if(!element->IsIceInElement()) continue;
2791 
2792  /*get H on the vertices*/
2793  element->GetInputListOnVertices(H,ThicknessEnum);
2794 
2795  /*weight to calculate the smoothed H*/
2796  weight=1.;//simple average
2797 
2798  /*add in the serial vector*/
2799  vecH->SetValue(element->vertices[0]->Sid(),weight*H[0],ADD_VAL);
2800  vecH->SetValue(element->vertices[1]->Sid(),weight*H[1],ADD_VAL);
2801  vecH->SetValue(element->vertices[2]->Sid(),weight*H[2],ADD_VAL);
2802  /*total weight*/
2803  vectotalweight->SetValue(element->vertices[0]->Sid(),weight,ADD_VAL);
2804  vectotalweight->SetValue(element->vertices[1]->Sid(),weight,ADD_VAL);
2805  vectotalweight->SetValue(element->vertices[2]->Sid(),weight,ADD_VAL);
2806  }
2807 
2808  /*Assemble and serialize*/
2809  vecH->Assemble();
2810  vectotalweight->Assemble();
2811  Hserial=vecH->ToMPISerial();
2812  totalweight=vectotalweight->ToMPISerial();
2813 
2814  /*Divide for the total weight*/
2815  for(int i=0;i<numberofvertices;i++){
2816  _assert_(totalweight[i]>0);
2817  Hserial[i]=Hserial[i]/totalweight[i];
2818  }
2819 
2820  /*Set element inputs*/
2821  for(int i=0;i<this->elements->Size();i++){
2822  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
2823  H[0]=Hserial[element->vertices[0]->Sid()];
2824  H[1]=Hserial[element->vertices[1]->Sid()];
2825  H[2]=Hserial[element->vertices[2]->Sid()];
2826  element->AddInput2(ThicknessEnum,H,P1Enum);
2827  }
2828 
2829  /*Cleanup*/
2830  delete vecH;
2831  delete vectotalweight;
2832  xDelete<IssmDouble>(H);
2833  xDelete<IssmDouble>(Hserial);
2834  xDelete<IssmDouble>(totalweight);
2835 }

◆ ThicknessAbsGradientx()

void FemModel::ThicknessAbsGradientx ( IssmDouble *  pJ)

Definition at line 2718 of file FemModel.cpp.

2718  {/*{{{*/
2719 
2720  /*output: */
2721  IssmDouble J=0.;
2722  IssmDouble J_sum;
2723 
2724  IssmDouble thickness,weight;
2725  IssmDouble Jdet;
2726  IssmDouble* xyz_list = NULL;
2727  IssmDouble dp[3];
2728 
2729  /*Compute Misfit: */
2730  for(int i=0;i<elements->Size();i++){
2731  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
2732 
2733  /*If on water, return 0: */
2734  if(!element->IsIceInElement()) continue;
2735 
2736  /* Get node coordinates*/
2737  element->GetVerticesCoordinates(&xyz_list);
2738 
2739  /*Retrieve all inputs we will be needing: */
2740  DatasetInput2* weights_input =element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
2741  Input2* thickness_input =element->GetInput2(ThicknessEnum); _assert_(thickness_input);
2742 
2743  /* Start looping on the number of gaussian points: */
2744  Gauss* gauss=element->NewGauss(2);
2745  for(int ig=gauss->begin();ig<gauss->end();ig++){
2746 
2747  gauss->GaussPoint(ig);
2748 
2749  /* Get Jacobian determinant: */
2750  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
2751 
2752  /*Get all parameters at gaussian point*/
2753  weights_input->GetInputValue(&weight,gauss,ThicknessAbsGradientEnum);
2754  thickness_input->GetInputDerivativeValue(&dp[0],xyz_list,gauss);
2755 
2756  /*Tikhonov regularization: J = 1/2 ((dp/dx)^2 + (dp/dy)^2) */
2757  J+=weight*1/2*(dp[0]*dp[0]+dp[1]*dp[1])*Jdet*gauss->weight;
2758  }
2759 
2760  /*clean up and Return: */
2761  xDelete<IssmDouble>(xyz_list);
2762  delete gauss;
2763  }
2764 
2765  /*Sum all J from all cpus of the cluster:*/
2766  ISSM_MPI_Reduce (&J,&J_sum,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
2767  ISSM_MPI_Bcast(&J_sum,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
2768  J=J_sum;
2769 
2770  /*Assign output pointers: */
2771  *pJ=J;
2772 }

◆ ThicknessPositivex()

void FemModel::ThicknessPositivex ( IssmDouble *  pJ)

Definition at line 2837 of file FemModel.cpp.

2837  {/*{{{*/
2838 
2839  /*output: */
2840  IssmDouble J=0.;
2841  IssmDouble J_sum;
2842 
2843  IssmDouble thickness,weight;
2844  IssmDouble Jdet;
2845  IssmDouble* xyz_list = NULL;
2846  IssmDouble H;
2847 
2848  /*Compute Misfit: */
2849  for(int i=0;i<elements->Size();i++){
2850  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
2851 
2852  /*If on water, return 0: */
2853  if(!element->IsIceInElement()) continue;
2854 
2855  /* Get node coordinates*/
2856  element->GetVerticesCoordinates(&xyz_list);
2857 
2858  /*Retrieve all inputs we will be needing: */
2859  DatasetInput2* weights_input =element->GetDatasetInput2(InversionCostFunctionsCoefficientsEnum); _assert_(weights_input);
2860  Input2* thickness_input =element->GetInput2(ThicknessEnum); _assert_(thickness_input);
2861 
2862  /* Start looping on the number of gaussian points: */
2863  Gauss* gauss=element->NewGauss(2);
2864  for(int ig=gauss->begin();ig<gauss->end();ig++){
2865 
2866  gauss->GaussPoint(ig);
2867 
2868  /* Get Jacobian determinant: */
2869  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
2870 
2871  /*Get all parameters at gaussian point*/
2872  weights_input->GetInputValue(&weight,gauss,ThicknessPositiveEnum);
2873  thickness_input->GetInputValue(&H,gauss);
2874 
2875  /*int min(H,0)^2 */
2876  if(H<=0){
2877  J+=weight*H*H*Jdet*gauss->weight;
2878  }
2879  }
2880 
2881  /*clean up and Return: */
2882  xDelete<IssmDouble>(xyz_list);
2883  delete gauss;
2884  }
2885 
2886  /*Sum all J from all cpus of the cluster:*/
2887  ISSM_MPI_Reduce (&J,&J_sum,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
2888  ISSM_MPI_Bcast(&J_sum,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
2889  J=J_sum;
2890 
2891  /*Assign output pointers: */
2892  *pJ=J;
2893 }

◆ HydrologyEPLupdateDomainx()

void FemModel::HydrologyEPLupdateDomainx ( IssmDouble *  pEplcount)

Definition at line 4965 of file FemModel.cpp.

4965  { /*{{{*/
4966 
4967  Vector<IssmDouble> *mask = NULL;
4968  Vector<IssmDouble> *recurence = NULL;
4969  Vector<IssmDouble> *active = NULL;
4970  IssmDouble *serial_mask = NULL;
4971  IssmDouble *serial_rec = NULL;
4972  IssmDouble *serial_active = NULL;
4973  IssmDouble *old_active = NULL;
4974  int *eplzigzag_counter = NULL;
4975  int eplflip_lock;
4976 
4977  HydrologyDCEfficientAnalysis *effanalysis = new HydrologyDCEfficientAnalysis();
4978  HydrologyDCInefficientAnalysis *inefanalysis = new HydrologyDCInefficientAnalysis();
4979 
4980  /*Step 1: update mask, the mask might be extended by residual and/or using downstream sediment head*/
4981  int numnodes = this->nodes->NumberOfNodes();
4982  mask=new Vector<IssmDouble>(numnodes);
4983  recurence=new Vector<IssmDouble>(numnodes);
4984  this->parameters->FindParam(&eplzigzag_counter,NULL,EplZigZagCounterEnum);
4985  this->parameters->FindParam(&eplflip_lock,HydrologydcEplflipLockEnum);
4986  GetVectorFromInputsx(&old_active,this,HydrologydcMaskEplactiveNodeEnum,NodeSIdEnum);
4987 
4988  for (int i=0;i<elements->Size();i++){
4989  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
4990  effanalysis->HydrologyEPLGetMask(mask,recurence,element);
4991  }
4992 
4993  /*check for changes and increment zigzag counter, change the mask if necessary*/
4994  recurence->Assemble();
4995  serial_rec=recurence->ToMPISerial();
4996  for (int i=0;i<nodes->Size();i++){
4997  Node* node=xDynamicCast<Node*>(nodes->GetObjectByOffset(i));
4998  if(serial_rec[node->Sid()]==1.)eplzigzag_counter[node->Lid()] ++;
4999  if(eplzigzag_counter[node->Lid()]>eplflip_lock && eplflip_lock!=0){
5000  mask->SetValue(node->Sid(),old_active[node->Sid()],INS_VAL);
5001  }
5002  }
5003  this->parameters->SetParam(eplzigzag_counter,this->nodes->Size(),EplZigZagCounterEnum);
5004  /*Assemble and serialize*/
5005  mask->Assemble();
5006  serial_mask=mask->ToMPISerial();
5007 
5008  xDelete<int>(eplzigzag_counter);
5009  xDelete<IssmDouble>(serial_rec);
5010  xDelete<IssmDouble>(old_active);
5011  delete mask;
5012  delete recurence;
5013 
5014  /*Update Mask*/
5015  InputUpdateFromVectorx(this,serial_mask,HydrologydcMaskEplactiveNodeEnum,NodeSIdEnum);
5016  xDelete<IssmDouble>(serial_mask);
5017  inefanalysis->ElementizeEplMask(this);
5018  /*Step 2: update node activity. If one element is connected to mask=1, all nodes are active*/
5019  active=new Vector<IssmDouble>(nodes->NumberOfNodes());
5020  for (int i=0;i<elements->Size();i++){
5021  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
5022  effanalysis->HydrologyEPLGetActive(active,element);
5023  }
5024 
5025  /*Assemble and serialize*/
5026  active->Assemble();
5027  serial_active=active->ToMPISerial();
5028  delete active;
5029 
5030 
5031  /*Update node activation accordingly*/
5032  int counter = 0; //this is probably not acurate but we are only interested in positivity
5033  for(int i=0;i<elements->Size();i++){
5034  Element *element = xDynamicCast<Element*>(elements->GetObjectByOffset(i));
5035  int numnodes = element->GetNumberOfNodes();
5036  IssmDouble *base = xNew<IssmDouble>(numnodes);
5037  element->GetInputListOnNodes(&base[0],BaseEnum);
5038  for(int in=0;in<numnodes;in++){
5039  Node* node=element->GetNode(in);
5040  if(serial_active[node->Sid()]==1.){
5041  node->Activate();
5042  if(!node->IsClone()) counter++;
5043  }
5044  else{
5045  node->Deactivate();
5046  node->ApplyConstraint(0,base[in]);
5047  }
5048  }
5049  xDelete<IssmDouble>(base);
5050  }
5051  xDelete<IssmDouble>(serial_active);
5052  delete effanalysis;
5053  delete inefanalysis;
5054  int sum_counter;
5055  ISSM_MPI_Reduce(&counter,&sum_counter,1,ISSM_MPI_INT,ISSM_MPI_SUM,0,IssmComm::GetComm() );
5056  ISSM_MPI_Bcast(&sum_counter,1,ISSM_MPI_INT,0,IssmComm::GetComm());
5057  counter=sum_counter;
5058  *pEplcount = counter;
5059  if(VerboseSolution()) {
5060  if(counter==0){
5061  _printf0_(" No nodes are active in EPL layer \n");
5062  }
5063  else {
5064  _printf0_(" Some active nodes in EPL layer \n");
5065  }
5066  }
5067 
5068  /*Update dof indexings*/
5069  this->UpdateConstraintsx();
5070 }

◆ HydrologyIDSupdateDomainx()

void FemModel::HydrologyIDSupdateDomainx ( IssmDouble *  pIDScount)

Definition at line 5072 of file FemModel.cpp.

5072  { /*{{{*/
5073 
5074  bool isthermal;
5075  Vector<IssmDouble>* mask = NULL;
5076  Vector<IssmDouble>* active = NULL;
5077  IssmDouble* serial_mask = NULL;
5078  IssmDouble* serial_active = NULL;
5079 
5080  HydrologyDCInefficientAnalysis* inefanalysis = new HydrologyDCInefficientAnalysis();
5081  parameters->FindParam(&isthermal,TransientIsthermalEnum);
5082 
5083  /*When solving a thermal model we update the thawed nodes*/
5084  if(isthermal){
5085  /*Step 1: update mask, the mask correspond to thawed nodes (that have a meltingrate)*/
5086  mask=new Vector<IssmDouble>(this->nodes->NumberOfNodes());
5087 
5088  for (int i=0;i<elements->Size();i++){
5089  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
5090  inefanalysis->HydrologyIDSGetMask(mask,element);
5091  }
5092  /*Assemble and serialize*/
5093  mask->Assemble();
5094  serial_mask=mask->ToMPISerial();
5095  delete mask;
5096  }
5097  /*for other cases we just grab the mask from the initialisation value*/
5098  else{
5099  GetVectorFromInputsx(&serial_mask,this,HydrologydcMaskThawedNodeEnum,NodeSIdEnum);
5100  }
5101  /*Update Mask and elementize*/
5102  InputUpdateFromVectorx(this,serial_mask,HydrologydcMaskThawedNodeEnum,NodeSIdEnum);
5103  xDelete<IssmDouble>(serial_mask);
5104  inefanalysis->ElementizeIdsMask(this);
5105 
5106  /*get node mask coherent with element mask*/
5107  active=new Vector<IssmDouble>(nodes->NumberOfNodes());
5108  for (int i=0;i<elements->Size();i++){
5109  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
5110  inefanalysis->HydrologyIdsGetActive(active,element);
5111  }
5112 
5113  /*Assemble and serialize*/
5114  active->Assemble();
5115  serial_active=active->ToMPISerial();
5116  delete active;
5117 
5118  /*Update node activation accordingly*/
5119  int counter = 0; //this is probably not acurate but we are only interested in positivity
5120  for(int i=0;i<elements->Size();i++){
5121  Element *element = xDynamicCast<Element*>(elements->GetObjectByOffset(i));
5122  int numnodes = element->GetNumberOfNodes();
5123  IssmDouble *base = xNew<IssmDouble>(numnodes);
5124 
5125  element->GetInputListOnNodes(&base[0],BaseEnum);
5126 
5127  for(int in=0;in<numnodes;in++){
5128  Node* node=element->GetNode(in);
5129  if(serial_active[node->Sid()]==1.){
5130  node->Activate();
5131  if(!node->IsClone()) counter++;
5132  }
5133  else{
5134  node->Deactivate();
5135  node->ApplyConstraint(0,base[in]);
5136  }
5137  }
5138  xDelete<IssmDouble>(base);
5139  }
5140  xDelete<IssmDouble>(serial_active);
5141  delete inefanalysis;
5142  int sum_counter;
5143  ISSM_MPI_Reduce(&counter,&sum_counter,1,ISSM_MPI_INT,ISSM_MPI_SUM,0,IssmComm::GetComm() );
5144  ISSM_MPI_Bcast(&sum_counter,1,ISSM_MPI_INT,0,IssmComm::GetComm());
5145  counter=sum_counter;
5146  *pIDScount = counter;
5147  if(VerboseSolution()) {
5148  if(counter==0){
5149  _printf0_(" No nodes are active in IDS layer \n");
5150  }
5151  else {
5152  _printf0_(" Some active nodes in IDS layer \n");
5153  }
5154  }
5155  /*Update dof indexings*/
5156  this->UpdateConstraintsx();
5157 
5158 }

◆ TimeAdaptx()

void FemModel::TimeAdaptx ( IssmDouble *  pdt)

Definition at line 2895 of file FemModel.cpp.

2895  {/*{{{*/
2896 
2897  /*output: */
2898  IssmDouble dt;
2899 
2900  /*intermediary: */
2901  IssmDouble min_dt = 0;
2902  IssmDouble node_min_dt = 0;
2903 
2904  /*Go through elements, and figure out the minimum of the time steps for each element (using CFL criterion): */
2905  Element* element=(Element*)elements->GetObjectByOffset(0); min_dt=element->TimeAdapt();
2906 
2907  for(int i=1;i<elements->Size();i++){
2908  element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
2909  dt=element->TimeAdapt();
2910  if(dt<min_dt)min_dt=dt;
2911  }
2912 
2913  /*Figure out minimum across the cluster: */
2914  ISSM_MPI_Reduce (&min_dt,&node_min_dt,1,ISSM_MPI_DOUBLE,ISSM_MPI_MIN,0,IssmComm::GetComm() );
2915  ISSM_MPI_Bcast(&node_min_dt,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
2916  min_dt=node_min_dt;
2917 
2918  /*Constrain dt */
2919  IssmDouble dt_low,dt_high;
2920  parameters->FindParam(&dt_low,TimesteppingTimeStepMinEnum);
2921  parameters->FindParam(&dt_high,TimesteppingTimeStepMaxEnum);
2922  if(min_dt<dt_low) min_dt = dt_low;
2923  if(min_dt>dt_high) min_dt = dt_high;
2924 
2925  /*Assign output pointers:*/
2926  *pdt=min_dt;
2927 }

◆ UpdateConstraintsExtrudeFromBasex()

void FemModel::UpdateConstraintsExtrudeFromBasex ( void  )

Definition at line 3009 of file FemModel.cpp.

3009  { /*{{{*/
3010 
3011  for(int i=0;i<elements->Size();i++){
3012  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
3013  element->UpdateConstraintsExtrudeFromBase();
3014  }
3015 
3016 }

◆ UpdateConstraintsExtrudeFromTopx()

void FemModel::UpdateConstraintsExtrudeFromTopx ( void  )

Definition at line 3018 of file FemModel.cpp.

3018  { /*{{{*/
3019 
3020  for(int i=0;i<elements->Size();i++){
3021  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
3022  element->UpdateConstraintsExtrudeFromTop();
3023  }
3024 
3025 }

◆ UpdateConstraintsL2ProjectionEPLx()

void FemModel::UpdateConstraintsL2ProjectionEPLx ( IssmDouble *  pL2count)

Definition at line 5160 of file FemModel.cpp.

5160  { /*{{{*/
5161 
5162  Vector<IssmDouble>* active = NULL;
5163  IssmDouble* serial_active = NULL;
5164  HydrologyDCEfficientAnalysis* effanalysis = new HydrologyDCEfficientAnalysis();
5165 
5166  /*update node activity. If one element is connected to mask=1, all nodes are active*/
5167  this->SetCurrentConfiguration(HydrologyDCEfficientAnalysisEnum);
5168  active=new Vector<IssmDouble>(nodes->NumberOfNodes());
5169  for (int i=0;i<elements->Size();i++){
5170  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
5171  effanalysis->HydrologyEPLGetActive(active,element);
5172  }
5173 
5174  /*Assemble and serialize*/
5175  active->Assemble();
5176  serial_active=active->ToMPISerial();
5177  delete active;
5178  delete effanalysis;
5179 
5180  /*Update node activation accordingly*/
5181  int counter =0;
5182  this->SetCurrentConfiguration(L2ProjectionEPLAnalysisEnum);
5183  for (int i=0;i<nodes->Size();i++){
5184  Node* node=xDynamicCast<Node*>(nodes->GetObjectByOffset(i));
5185  if(serial_active[node->Sid()]==1.){
5186  node->Activate();
5187  if(!node->IsClone()) counter++;
5188  }
5189  else{
5190  node->Deactivate();
5191  }
5192  }
5193  xDelete<IssmDouble>(serial_active);
5194  int sum_counter;
5195  ISSM_MPI_Reduce(&counter,&sum_counter,1,ISSM_MPI_INT,ISSM_MPI_SUM,0,IssmComm::GetComm() );
5196  ISSM_MPI_Bcast(&sum_counter,1,ISSM_MPI_INT,0,IssmComm::GetComm());
5197  counter=sum_counter;
5198  *pL2count = counter;
5199  if(VerboseSolution()) _printf0_(" Number of active nodes L2 Projection: "<< counter <<"\n");
5200 }

◆ InitTransientInputx()

void FemModel::InitTransientInputx ( int *  transientinput_enum,
int  numoutputs 
)

Definition at line 5202 of file FemModel.cpp.

5202  { /*{{{*/
5203 
5204  for(int i=0;i<numoutputs;i++){
5205  this->inputs2->DeleteInput(transientinput_enum[i]);
5206  this->inputs2->SetTransientInput(transientinput_enum[i],NULL,0);
5207  /*We need to configure this input!*/
5208  TransientInput2* transientinput = this->inputs2->GetTransientInput(transientinput_enum[i]); _assert_(transientinput);
5209  transientinput->Configure(this->parameters);
5210  }
5211 }

◆ StackTransientInputx()

void FemModel::StackTransientInputx ( int *  input_enum,
int *  transientinput_enum,
IssmDouble  hydrotime,
int  numoutputs 
)

Definition at line 5213 of file FemModel.cpp.

5213  { /*{{{*/
5214 
5215  for(int i=0;i<numoutputs;i++){
5216  if(input_enum[i]<0){
5217  _error_("Can't deal with non enum fields for result Stack");
5218  }
5219  else{
5220  for(int j=0;j<elements->Size();j++){
5221 
5222  /*Get the right transient input*/
5223  Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(j));
5224  TransientInput2* transientinput = this->inputs2->GetTransientInput(transientinput_enum[i]);
5225 
5226  /*Get values and lid list*/
5227  const int numvertices = element->GetNumberOfVertices();
5228  IssmDouble* values=xNew<IssmDouble>(numvertices);
5229  int *vertexlids = xNew<int>(numvertices);
5230  element->GetInputListOnVertices(&values[0],input_enum[i]); //this is the enum to stack
5231 
5232  element->GetVerticesLidList(vertexlids);
5233 
5234  switch(element->ObjectEnum()){
5235  case TriaEnum: transientinput->AddTriaTimeInput(subtime,numvertices,vertexlids,values,P1Enum); break;
5236  case PentaEnum: transientinput->AddPentaTimeInput(subtime,numvertices,vertexlids,values,P1Enum); break;
5237  default: _error_("Not implemented yet");
5238  }
5239  xDelete<IssmDouble>(values);
5240  xDelete<int>(vertexlids);
5241  }
5242  }
5243  }
5244 }

◆ AverageTransientInputx()

void FemModel::AverageTransientInputx ( int *  transientinput_enum,
int *  averagedinput_enum,
IssmDouble  init_time,
IssmDouble  end_time,
int  numoutputs,
int  averaging_method 
)

Definition at line 5246 of file FemModel.cpp.

5246  { /*{{{*/
5247 
5248  for(int i=0;i<numoutputs;i++){
5249  for(int j=0;j<this->elements->Size();j++){
5250  Element* element = xDynamicCast<Element*>(elements->GetObjectByOffset(j));
5251  element->CreateInputTimeAverage(transientinput_enum[i],averagedinput_enum[i],init_time,end_time,averaging_method);
5252  }
5253  }
5254 }/*}}}*/

◆ UpdateConstraintsx()

void FemModel::UpdateConstraintsx ( void  )

Definition at line 3027 of file FemModel.cpp.

3027  { /*{{{*/
3028 
3029  IssmDouble time;
3030  int analysis_type,config_type;
3031 
3032  /*retrieve parameters: */
3033  parameters->FindParam(&analysis_type,AnalysisTypeEnum);
3034  parameters->FindParam(&config_type,ConfigurationTypeEnum);
3035  parameters->FindParam(&time,TimeEnum);
3036 
3037  int index=AnalysisIndex(config_type);
3038  _assert_(this->analysis_type_list[index]==config_type);
3039 
3040  /*start module: */
3041  if(VerboseModule()) _printf0_(" Updating constraints and active domain of analysis " << EnumToStringx(analysis_type) << " for time: " << time << "\n");
3042 
3043  Analysis* analysis= EnumToAnalysis(analysis_type);
3044  analysis->UpdateConstraints(this);
3045  delete analysis;
3046 
3047  /*Second, constraints might be time dependent: */
3048  SpcNodesx(nodes,constraints,parameters);
3049 
3050  /*Now, update degrees of freedoms: */
3051  NodesDofx(nodes,parameters);
3052 
3053 }

◆ UpdateVertexPositionsx()

int FemModel::UpdateVertexPositionsx ( void  )

Definition at line 3055 of file FemModel.cpp.

3055  { /*{{{*/
3056 
3057  IssmDouble *surface = NULL;
3058  IssmDouble *bed = NULL;
3059 
3060  if(VerboseSolution()) _printf0_(" updating vertices positions\n");
3061 
3062  /*get vertex vectors for bed and thickness: */
3063  GetVectorFromInputsx(&surface ,this, SurfaceEnum,VertexPIdEnum);
3064  GetVectorFromInputsx(&bed ,this, BaseEnum, VertexPIdEnum);
3065 
3066  /*Allocate vector*/
3067  int numvert = vertices->NumberOfVertices();
3068  int numvert_local = vertices->NumberOfVerticesLocal();
3069  Vector<IssmDouble> *vx=new Vector<IssmDouble>(numvert_local,numvert);
3070  Vector<IssmDouble> *vy=new Vector<IssmDouble>(numvert_local,numvert);
3071  Vector<IssmDouble> *vz=new Vector<IssmDouble>(numvert_local,numvert);
3072 
3073  /*Update verices new geometry: */
3074  for(int i=0;i<vertices->Size();i++){
3075  Vertex* vertex=(Vertex*)vertices->GetObjectByOffset(i);
3076  vertex->UpdatePosition(vx,vy,vz,parameters,surface,bed);
3077  }
3078 
3079  /*Assemble mesh velocity*/
3080  vx->Assemble();
3081  vy->Assemble();
3082  vz->Assemble();
3083 
3084  /*Update element inputs*/
3085  InputUpdateFromVectorx(this,vx,VxMeshEnum,VertexPIdEnum);
3086  InputUpdateFromVectorx(this,vy,VyMeshEnum,VertexPIdEnum);
3087  InputUpdateFromVectorx(this,vz,VzMeshEnum,VertexPIdEnum);
3088 
3089  /*Free ressources:*/
3090  delete vx;
3091  delete vy;
3092  delete vz;
3093  xDelete<IssmDouble>(bed);
3094  xDelete<IssmDouble>(surface);
3095  return 1;
3096 }

◆ ReMesh()

void FemModel::ReMesh ( void  )

Definition at line 3101 of file FemModel.cpp.

3101  {/*{{{*/
3102 
3103  /*Intermediaries*/
3104  IssmDouble *newx = NULL;
3105  IssmDouble *newy = NULL;
3106  IssmDouble *newz = NULL;
3107  int *newelementslist = NULL;
3108  int newnumberofvertices = -1;
3109  int newnumberofelements = -1;
3110 
3111  int elementswidth = this->GetElementsWidth();//just tria elements in this version
3112  int amrtype,basalforcing_model;
3113  bool isgroundingline;
3114 
3115  /*Branch to specific amr depending on requested method*/
3116  this->parameters->FindParam(&amrtype,AmrTypeEnum);
3117  switch(amrtype){
3118  #if defined(_HAVE_NEOPZ_) && !defined(_HAVE_AD_)
3119  case AmrNeopzEnum: this->ReMeshNeopz(&newnumberofvertices,&newnumberofelements,&newx,&newy,&newz,&newelementslist); break;
3120  #endif
3121 
3122  #if defined(_HAVE_BAMG_) && !defined(_HAVE_AD_)
3123  case AmrBamgEnum: this->ReMeshBamg(&newnumberofvertices,&newnumberofelements,&newx,&newy,&newz,&newelementslist); break;
3124  #endif
3125 
3126  default: _error_("not implemented yet");
3127  }
3128 
3129  /*Create iomodel for model processing*/
3130  IoModel* iomodel = new IoModel();
3131  this->parameters->FindParam(&iomodel->domaintype,DomainTypeEnum);
3132  this->parameters->FindParam(&iomodel->domaindim ,DomainDimensionEnum);
3133  this->parameters->FindParam(&iomodel->meshelementtype,MeshElementtypeEnum);
3134  iomodel->numberofvertices = newnumberofvertices;
3135  iomodel->numberofelements = newnumberofelements;
3136  iomodel->elements = newelementslist;
3137  iomodel->AddConstant(new IoConstant(0,"md.rifts.numrifts"));
3138  iomodel->AddConstant(new IoConstant(false,"md.transient.isoceancoupling"));
3139  bool temp; int tempint;
3140  this->parameters->FindParam(&temp,FlowequationIsSIAEnum); iomodel->AddConstant(new IoConstant(temp,"md.flowequation.isSIA"));
3141  this->parameters->FindParam(&temp,FlowequationIsSSAEnum); iomodel->AddConstant(new IoConstant(temp,"md.flowequation.isSSA"));
3142  this->parameters->FindParam(&temp,FlowequationIsL1L2Enum); iomodel->AddConstant(new IoConstant(temp,"md.flowequation.isL1L2"));
3143  this->parameters->FindParam(&temp,FlowequationIsHOEnum); iomodel->AddConstant(new IoConstant(temp,"md.flowequation.isHO"));
3144  this->parameters->FindParam(&temp,FlowequationIsFSEnum); iomodel->AddConstant(new IoConstant(temp,"md.flowequation.isFS"));
3145  this->parameters->FindParam(&tempint,MasstransportStabilizationEnum); iomodel->AddConstant(new IoConstant(tempint,"md.masstransport.stabilization"));
3146  iomodel->AddConstant(new IoConstant(P1Enum,"md.flowequation.fe_SSA"));
3147 
3148  /*Partitioning the new mesh. Maybe ElementsAndVerticesPartitioning.cpp could be modified to set this without iomodel.*/
3149  ::ElementsAndVerticesPartitioning(iomodel);
3150 
3151  /*Creating elements*/
3152  /*Just Tria in this version*/
3153  Elements* new_elements=new Elements();
3154  this->CreateElements(newnumberofelements,elementswidth,newelementslist,iomodel->my_elements,new_elements);
3155 
3156  /*Create vertices*/
3157  Vertices* new_vertices=new Vertices();
3158  CreateNumberNodeToElementConnectivity(iomodel);
3159  ::CreateVertices(new_elements,new_vertices,iomodel,TransientSolutionEnum,true);
3160  for(int i=0;i<new_vertices->Size();i++){
3161  Vertex *vertex=(Vertex*)new_vertices->GetObjectByOffset(i);
3162  int sid = vertex->Sid();
3163  vertex->x=newx[sid];
3164  vertex->y=newy[sid];
3165  vertex->z=newz[sid];
3166  }
3167 
3168  /*Creating inputs*/
3169  Inputs2* new_inputs2=new Inputs2(newnumberofelements,newnumberofvertices);
3170 
3171  /*Creating materials*/
3172  Materials* new_materials=new Materials();
3173  this->CreateMaterials(newnumberofelements,iomodel->my_elements,new_materials);
3174 
3175  /*Creating nodes and constraints*/
3176  /*Just SSA (2D) and P1 in this version*/
3177  Constraints **new_constraints_list = xNew<Constraints*>(this->nummodels);
3178  Nodes **new_nodes_list = xNew<Nodes*>(this->nummodels);
3179 
3180  this->analysis_counter=-1;
3181  for(int i=0;i<this->nummodels;i++){//create nodes for each analysis in analysis_type_list
3182 
3183  int analysis_enum = this->analysis_type_list[i];
3184  if(VerboseMProcessor()) _printf0_(" creating datasets for analysis " << EnumToStringx(analysis_enum) << "\n");
3185 
3186  if(this->loads_list[i]->Size()!=0) _error_("not supported yet");
3187  new_constraints_list[i] = new Constraints();
3188  new_nodes_list[i] = new Nodes();
3189 
3190  /*As the domain is 2D, it is not necessary to create nodes for this analysis*/
3191  if(analysis_enum==StressbalanceVerticalAnalysisEnum) continue;
3192  Analysis* analysis = EnumToAnalysis(analysis_enum);
3193  analysis->CreateNodes(new_nodes_list[i],iomodel,true);
3194  delete analysis;
3195  this->UpdateElements(newnumberofelements,newelementslist,iomodel->my_elements,i,new_elements);
3196  this->CreateConstraints(new_vertices,analysis_enum,new_constraints_list[i]);
3197 
3198  new_constraints_list[i]->Presort();
3199  new_nodes_list[i]->Presort();
3200  }
3201 
3202  new_elements->Presort();
3203  new_vertices->Presort();
3204  //this->loads->Presort();
3205  new_materials->Presort();
3206 
3207  /*reset hooks*/
3208  new_elements->ResetHooks();
3209  //this->loads->ResetHooks();
3210  new_materials->ResetHooks();
3211 
3212  /*do the post-processing of the datasets to get an FemModel that can actually run analyses: */
3213  int analysis_type;
3214  for(int i=0;i<this->nummodels;i++){
3215  analysis_type=this->analysis_type_list[i];
3216  SetCurrentConfiguration(analysis_type);
3217 
3218  this->analysis_counter=i;
3219  /*Now, plug analysis_counter and analysis_type inside the parameters: */
3220  this->parameters->SetParam(this->analysis_counter,AnalysisCounterEnum);
3221  this->parameters->SetParam(analysis_type,AnalysisTypeEnum);
3222  this->parameters->SetParam(analysis_type,ConfigurationTypeEnum);
3223 
3224  /*configure elements, loads and nodes, for this new analysis: */
3225  new_elements->SetCurrentConfiguration(new_elements,this->loads,new_nodes_list[i],new_vertices,new_materials,this->parameters);
3226  this->loads->SetCurrentConfiguration(new_elements,this->loads,new_nodes_list[i],new_vertices,new_materials,this->parameters);
3227 
3228  /*take care of toolkits options, that depend on this analysis type (present only after model processor)*/
3229  if(this->parameters->Exist(ToolkitsOptionsStringsEnum)){
3230  ToolkitsOptionsFromAnalysis(this->parameters,analysis_type);
3231  if(VerboseSolver()) _printf0_(" toolkits Options set for analysis type: " << EnumToStringx(analysis_type) << "\n");
3232  }
3233 
3234  ConfigureObjectsx(new_elements,this->loads,new_nodes_list[i],new_vertices,new_materials,this->parameters,new_inputs2);
3235  SpcNodesx(new_nodes_list[i],new_constraints_list[i],this->parameters);
3236  NodesDofx(new_nodes_list[i],this->parameters);
3237  }
3238 
3239  /*Interpolate all inputs and insert them into the new elements.*/
3240  this->InterpolateInputs(new_vertices,new_elements,new_inputs2);
3241 
3242  /*Delete old structure and set new pointers*/
3243  delete this->inputs2; this->inputs2 = new_inputs2;
3244  delete this->vertices; this->vertices = new_vertices;
3245  delete this->elements; this->elements = new_elements;
3246  delete this->materials; this->materials = new_materials;
3247  if(this->constraints_list && this->nummodels){
3248  for(int i=0;i<this->nummodels;i++) delete this->constraints_list[i];
3249  xDelete<Constraints*>(this->constraints_list);
3250  }
3251  this->constraints_list= new_constraints_list;
3252  if(this->nodes_list && this->nummodels){
3253  for(int i=0;i<this->nummodels;i++) delete this->nodes_list[i];
3254  xDelete<Nodes*>(this->nodes_list);
3255  }
3256  this->nodes_list = new_nodes_list;
3257 
3258  /*Reset mask*/
3259  GetMaskOfIceVerticesLSMx0(this);
3260 
3261  /*Insert MISMIP+ bed topography FIXME it could be stay in another place*/
3262  this->parameters->FindParam(&basalforcing_model,BasalforcingsEnum);
3263  if(basalforcing_model==MismipFloatingMeltRateEnum) this->BedrockFromMismipPlus();
3264 
3265  /*Adjust base, thickness and mask grounded ice leve set*/
3266  this->parameters->FindParam(&isgroundingline,TransientIsgroundinglineEnum);
3267  if(isgroundingline) this->AdjustBaseThicknessAndMask();
3268 
3269  /*Reset current configuration: */
3270  analysis_type=this->analysis_type_list[this->analysis_counter];
3271  SetCurrentConfiguration(analysis_type);
3272 
3273  /*Set the new mesh*/
3274  this->SetMesh(&newelementslist,&newx,&newy,&newnumberofvertices,&newnumberofelements);
3275 
3276  /*Cleanup*/
3277  xDelete<IssmDouble>(newz);
3278  /*Delete iomodel, but make sure to not erase some pointers*/
3279  iomodel->elements = NULL;
3280  delete iomodel;
3281 }

◆ BedrockFromMismipPlus()

void FemModel::BedrockFromMismipPlus ( void  )

Definition at line 3283 of file FemModel.cpp.

3283  {/*{{{*/
3284 
3285  /*Insert bedrock from mismip+ setup*/
3286  /*This was used to Misomip project/simulations*/
3287 
3288  if(VerboseSolution())_printf0_(" call Mismip bedrock adjust module\n");
3289 
3290  IssmDouble x,y,bx,by;
3291  int numvertices = this->GetElementsWidth();
3292  IssmDouble* xyz_list = NULL;
3293  IssmDouble* r = xNew<IssmDouble>(numvertices);
3294 
3295  for(int el=0;el<this->elements->Size();el++){
3296  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(el));
3297  element->GetVerticesCoordinates(&xyz_list);
3298  for(int i=0;i<numvertices;i++){
3299  x = xyz_list[3*i+0];
3300  y = xyz_list[3*i+1];
3301  bx = -150.-728.8*pow(x/300000.,2)+343.91*pow(x/300000.,4)-50.57*pow(x/300000.,6);
3302  by = 500./(1.+exp((-2./4000.)*(y-80000./2.-24000.)))+500./(1.+exp((2./4000.)*(y-80000./2.+24000.)));
3303  r[i] = max(bx+by,-720.);
3304  }
3305  /*insert new bedrock*/
3306  element->AddInput2(BedEnum,&r[0],P1Enum);
3307  /*Cleanup*/
3308  xDelete<IssmDouble>(xyz_list);
3309  }
3310  /*Delete*/
3311  xDelete<IssmDouble>(r);
3312 }

◆ AdjustBaseThicknessAndMask()

void FemModel::AdjustBaseThicknessAndMask ( void  )

Definition at line 3314 of file FemModel.cpp.

3314  {/*{{{*/
3315 
3316  if(VerboseSolution())_printf0_(" call adjust base and thickness module\n");
3317 
3318  int numvertices = this->GetElementsWidth();
3319  IssmDouble rho_water,rho_ice,density,base_float;
3320  IssmDouble* phi = xNew<IssmDouble>(numvertices);
3321  IssmDouble* h = xNew<IssmDouble>(numvertices);
3322  IssmDouble* s = xNew<IssmDouble>(numvertices);
3323  IssmDouble* b = xNew<IssmDouble>(numvertices);
3324  IssmDouble* r = xNew<IssmDouble>(numvertices);
3325  IssmDouble* sl = xNew<IssmDouble>(numvertices);
3326 
3327  for(int el=0;el<this->elements->Size();el++){
3328  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(el));
3329 
3330  element->GetInputListOnVertices(&s[0],SurfaceEnum);
3331  element->GetInputListOnVertices(&r[0],BedEnum);
3332  element->GetInputListOnVertices(&sl[0],SealevelEnum);
3333  rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
3334  rho_ice = element->FindParam(MaterialsRhoIceEnum);
3335  density = rho_ice/rho_water;
3336 
3337  for(int i=0;i<numvertices;i++){
3338  /*calculate base floatation (which supports given surface*/
3339  base_float = rho_ice*s[i]/(rho_ice-rho_water);
3340  if(r[i]>base_float){
3341  b[i] = r[i];
3342  }
3343  else {
3344  b[i] = base_float;
3345  }
3346 
3347  if(fabs(sl[i])>0) _error_("Sea level value "<<sl[i]<<" not supported!");
3348  /*update thickness and mask grounded ice level set*/
3349  h[i] = s[i]-b[i];
3350  phi[i] = h[i]+r[i]/density;
3351  }
3352 
3353  /*Update inputs*/
3354  element->AddInput2(MaskOceanLevelsetEnum,&phi[0],P1Enum);
3355  element->AddInput2(ThicknessEnum,&h[0],P1Enum);
3356  element->AddInput2(BaseEnum,&b[0],P1Enum);
3357  }
3358 
3359  /*Delete*/
3360  xDelete<IssmDouble>(phi);
3361  xDelete<IssmDouble>(h);
3362  xDelete<IssmDouble>(s);
3363  xDelete<IssmDouble>(b);
3364  xDelete<IssmDouble>(r);
3365  xDelete<IssmDouble>(sl);
3366 }

◆ GetMesh() [1/2]

void FemModel::GetMesh ( Vertices *  femmodel_vertices,
Elements *  femmodel_elements,
IssmDouble **  px,
IssmDouble **  py,
int **  pelementslist 
)

Definition at line 3731 of file FemModel.cpp.

3731  {/*{{{*/
3732 
3733  if(!femmodel_vertices) _error_("GetMesh: vertices are NULL.");
3734  if(!femmodel_elements) _error_("GetMesh: elements are NULL.");
3735 
3736  int numberofvertices = femmodel_vertices->NumberOfVertices();
3737  int numberofelements = femmodel_elements->NumberOfElements();
3738  int elementswidth = this->GetElementsWidth(); // just 2D mesh in this version (just tria elements)
3739  IssmDouble* x = NULL;
3740  IssmDouble* y = NULL;
3741  IssmDouble* z = NULL;
3742  int* elementslist = NULL;
3743  int* elem_vertices = NULL;
3744  IssmDouble *id1 = NULL;
3745  IssmDouble *id2 = NULL;
3746  IssmDouble *id3 = NULL;
3747 
3748  /*Get vertices coordinates*/
3749  VertexCoordinatesx(&x,&y,&z,femmodel_vertices,false) ;
3750 
3751  /*Get element vertices*/
3752  elem_vertices = xNew<int>(elementswidth);
3753  Vector<IssmDouble>* vid1= new Vector<IssmDouble>(numberofelements);
3754  Vector<IssmDouble>* vid2= new Vector<IssmDouble>(numberofelements);
3755  Vector<IssmDouble>* vid3= new Vector<IssmDouble>(numberofelements);
3756 
3757  /*Go through elements, and for each element, get vertices*/
3758  for(int i=0;i<femmodel_elements->Size();i++){
3759  Element* element=xDynamicCast<Element*>(femmodel_elements->GetObjectByOffset(i));
3760  element->GetVerticesSidList(elem_vertices);
3761  vid1->SetValue(element->sid,elem_vertices[0],INS_VAL);
3762  vid2->SetValue(element->sid,elem_vertices[1],INS_VAL);
3763  vid3->SetValue(element->sid,elem_vertices[2],INS_VAL);
3764  }
3765 
3766  /*Assemble*/
3767  vid1->Assemble();
3768  vid2->Assemble();
3769  vid3->Assemble();
3770 
3771  /*Serialize*/
3772  id1 = vid1->ToMPISerial();
3773  id2 = vid2->ToMPISerial();
3774  id3 = vid3->ToMPISerial();
3775 
3776  /*Construct elements list*/
3777  elementslist=xNew<int>(numberofelements*elementswidth);
3778  if(numberofelements*elementswidth<0) _error_("numberofelements negative.");
3779  for(int i=0;i<numberofelements;i++){
3780  elementslist[elementswidth*i+0] = reCast<int>(id1[i])+1; //InterpMesh wants Matlab indexing
3781  elementslist[elementswidth*i+1] = reCast<int>(id2[i])+1; //InterpMesh wants Matlab indexing
3782  elementslist[elementswidth*i+2] = reCast<int>(id3[i])+1; //InterpMesh wants Matlab indexing
3783  }
3784 
3785  /*Assign pointers*/
3786  *px = x;
3787  *py = y;
3788  *pelementslist = elementslist; //Matlab indexing. InterMesh uses this type.
3789 
3790  /*Cleanup*/
3791  xDelete<int>(elem_vertices);
3792  xDelete<IssmDouble>(id1);
3793  xDelete<IssmDouble>(id2);
3794  xDelete<IssmDouble>(id3);
3795  xDelete<IssmDouble>(z);
3796  delete vid1;
3797  delete vid2;
3798  delete vid3;
3799 }

◆ GetMesh() [2/2]

void FemModel::GetMesh ( int **  elementslist,
IssmDouble **  x,
IssmDouble **  y,
int *  numberofvertices,
int *  numberofelements 
)

Definition at line 3801 of file FemModel.cpp.

3801  {/*{{{*/
3802 
3803  int amrtype;
3804  this->parameters->FindParam(&amrtype,AmrTypeEnum);
3805 
3806  switch(amrtype){
3807 
3808  #if defined(_HAVE_NEOPZ_)
3809  case AmrNeopzEnum: this->amr->GetMesh(elementslist,x,y,numberofvertices,numberofelements); break;
3810  #endif
3811 
3812  #if defined(_HAVE_BAMG_)
3813  case AmrBamgEnum: this->amrbamg->GetMesh(elementslist,x,y,numberofvertices,numberofelements); break;
3814  #endif
3815 
3816  default: _error_("not implemented yet");
3817  }
3818 }/*}}}*/

◆ SetMesh()

void FemModel::SetMesh ( int **  elementslist,
IssmDouble **  x,
IssmDouble **  y,
int *  numberofvertices,
int *  numberofelements 
)

Definition at line 3819 of file FemModel.cpp.

3819  {/*{{{*/
3820 
3821  int amrtype;
3822  this->parameters->FindParam(&amrtype,AmrTypeEnum);
3823 
3824  switch(amrtype){
3825 
3826  #if defined(_HAVE_NEOPZ_)
3827  case AmrNeopzEnum: this->amr->SetMesh(elementslist,x,y,numberofvertices,numberofelements); break;
3828  #endif
3829 
3830  #if defined(_HAVE_BAMG_)
3831  case AmrBamgEnum: this->amrbamg->SetMesh(elementslist,x,y,numberofvertices,numberofelements); break;
3832  #endif
3833 
3834  default: _error_("not implemented yet");
3835  }
3836 }/*}}}*/

◆ GetMeshOnPartition()

void FemModel::GetMeshOnPartition ( Vertices *  femmodel_vertices,
Elements *  femmodel_elements,
IssmDouble **  px,
IssmDouble **  py,
IssmDouble **  pz,
int **  pelementslist,
int **  psidtoindex 
)

Definition at line 3837 of file FemModel.cpp.

3837  {/*{{{*/
3838 
3839  if(!femmodel_vertices) _error_("GetMesh: vertices are NULL.");
3840  if(!femmodel_elements) _error_("GetMesh: elements are NULL.");
3841 
3842  int numberofvertices = femmodel_vertices->Size(); //number of vertices of this partition
3843  int numbertotalofvertices = femmodel_vertices->NumberOfVertices(); //number total of vertices (entire mesh)
3844  int numberofelements = femmodel_elements->Size(); //number of elements of this partition
3845  int elementswidth = this->GetElementsWidth(); //just 2D mesh in this version (just tria elements)
3846  IssmDouble* x = NULL;
3847  IssmDouble* y = NULL;
3848  IssmDouble* z = NULL;
3849  int* elementslist = NULL;
3850  int* sidtoindex = NULL;
3851  int* elem_vertices = NULL;
3852 
3853  /*Get vertices coordinates of this partition*/
3854  sidtoindex = xNewZeroInit<int>(numbertotalofvertices);//entire mesh, all vertices
3855  x = xNew<IssmDouble>(numberofvertices);//just this partition
3856  y = xNew<IssmDouble>(numberofvertices);//just this partitio;
3857  z = xNew<IssmDouble>(numberofvertices);//just this partitio;
3858 
3859  /*Go through in this partition (vertices)*/
3860  for(int i=0;i<numberofvertices;i++){//just this partition
3861  Vertex* vertex=(Vertex*)femmodel_vertices->GetObjectByOffset(i);
3862  /*Attention: no spherical coordinates*/
3863  x[i]=vertex->GetX();
3864  y[i]=vertex->GetY();
3865  z[i]=vertex->GetZ();
3866  /*Keep the index and sid pair*/
3867  sidtoindex[vertex->Sid()]=i;
3868  }
3869 
3870  /*Go through in this partition (elements) and build the element list*/
3871  elem_vertices= xNew<int>(elementswidth);
3872  elementslist = xNew<int>(numberofelements*elementswidth);
3873  if(numberofelements*elementswidth<0) _error_("numberofelements negative.");
3874 
3875  for(int i=0;i<numberofelements;i++){//just this partition
3876  Element* element=xDynamicCast<Element*>(femmodel_elements->GetObjectByOffset(i));
3877  element->GetVerticesSidList(elem_vertices);
3878  elementslist[elementswidth*i+0] = sidtoindex[elem_vertices[0]]+1; //InterpMesh wants Matlab indexing
3879  elementslist[elementswidth*i+1] = sidtoindex[elem_vertices[1]]+1; //InterpMesh wants Matlab indexing
3880  elementslist[elementswidth*i+2] = sidtoindex[elem_vertices[2]]+1; //InterpMesh wants Matlab indexing
3881  }
3882 
3883  /*Assign pointers*/
3884  *px = x;
3885  *py = y;
3886  *pz = z;
3887  *pelementslist = elementslist; //Matlab indexing. InterMesh uses this type.
3888  *psidtoindex = sidtoindex; //it is ncessary to insert inputs
3889 
3890  /*Cleanup*/
3891  xDelete<int>(elem_vertices);
3892 }

◆ CreateElements()

void FemModel::CreateElements ( int  newnumberofelements,
int  elementswidth,
int *  newelementslist,
bool *  my_elements,
Elements *  elements 
)

Definition at line 3675 of file FemModel.cpp.

3675  {/*{{{*/
3676 
3677  /*newlementslist is in Matlab indexing*/
3678  int lid=0;
3679  for(int i=0;i<newnumberofelements;i++){
3680  if(my_elements[i]){
3681  /*Create element - just tria in this version*/
3682  Tria *newtria=new Tria();
3683  newtria->id=i+1;
3684  newtria->sid=i;
3685  newtria->lid=lid++;
3686  newtria->iscollapsed=0;
3687  newtria->isonsurface = true;
3688  newtria->isonbase = true;
3689  newtria->parameters=NULL;
3690  newtria->inputs2=NULL;
3691  newtria->nodes=NULL;
3692  newtria->vertices=NULL;
3693  newtria->material=NULL;
3694  if(this->nummodels>0){
3695  newtria->element_type_list=xNew<int>(this->nummodels);
3696  for(int j=0;j<nummodels;j++) newtria->element_type_list[j]=0;
3697  }
3698  else newtria->element_type_list=NULL;
3699 
3700  /*Element hook*/
3701  int material_id=i+1; // retrieve material_id = i+1;
3702  /*retrieve vertices ids*/
3703  int* vertex_ids=xNew<int>(elementswidth);
3704  for(int j=0;j<elementswidth;j++) vertex_ids[j]=reCast<int>(newelementslist[elementswidth*i+j]);//this Hook wants Matlab indexing
3705  /*Setting the hooks*/
3706  newtria->numanalyses =this->nummodels;
3707  newtria->hnodes =new Hook*[this->nummodels];
3708  newtria->hvertices =new Hook(&vertex_ids[0],elementswidth);
3709  newtria->hmaterial =new Hook(&material_id,1);
3710  newtria->hneighbors =NULL;
3711  /*Initialize hnodes as NULL*/
3712  for(int j=0;j<this->nummodels;j++) newtria->hnodes[j]=NULL;
3713  /*Clean up*/
3714  xDelete<int>(vertex_ids);
3715  elements->AddObject(newtria);
3716  }
3717  }
3718 
3719 }

◆ CreateMaterials()

void FemModel::CreateMaterials ( int  newnumberofelements,
bool *  my_elements,
Materials *  materials 
)

Definition at line 3721 of file FemModel.cpp.

3721  {/*{{{*/
3722 
3723  /*Just Matice in this version*/
3724  for(int i=0;i<newnumberofelements;i++){
3725  if(my_elements[i]){
3726  materials->AddObject(new Matice(i+1,i,MaticeEnum));
3727  }
3728  }
3729 }

◆ CreateConstraints()

void FemModel::CreateConstraints ( Vertices *  newfemmodel_vertices,
int  analysis_enum,
Constraints *  newfemmodel_constraints 
)

Definition at line 3894 of file FemModel.cpp.

3894  {/*{{{*/
3895 
3896  /*ATTENTION: JUST SPCVX AND SPCVY*/
3897  /*OTHERS CONSTRAINTS MUST BE IMPLEMENTED*/
3898  if(analysis_enum!=StressbalanceAnalysisEnum) return;
3899  int analysis_index = AnalysisIndex(analysis_enum);
3900 
3901  int numberofnodes_analysistype= this->nodes_list[analysis_index]->NumberOfNodes();
3902  int dofpernode = 2; //vx and vy
3903  int numberofcols = dofpernode*2; //to keep dofs and flags in the vspc vector
3904  int numberofvertices = -1; //global, entire old mesh
3905  int numberofelements = -1; //global, entire old mesh
3906  int newnumberofvertices = newfemmodel_vertices->Size(); //local, just the new partition
3907  int count = 0;
3908  IssmDouble* x = NULL; //global, entire old mesh
3909  IssmDouble* y = NULL; //global, entire old mesh
3910  int* elementslist = NULL; //global, entire old mesh
3911  IssmDouble* spc = NULL; //global, entire old mesh
3912  IssmDouble* newx = NULL; //local, just new partition
3913  IssmDouble* newy = NULL; //local, just new partition
3914  IssmDouble* newspc = NULL; //local, just new partition
3915  IssmDouble eps = 1.e-8;
3916  Vector<IssmDouble>* vspc = new Vector<IssmDouble>(numberofnodes_analysistype*numberofcols);
3917 
3918  /*Get old mesh (global, entire mesh). Elementslist comes in Matlab indexing*/
3919  this->GetMesh(&elementslist,&x,&y,&numberofvertices,&numberofelements);
3920 
3921  /*Get vertices coordinates of the new partition*/
3922  newx=xNew<IssmDouble>(newnumberofvertices);//just the new partition
3923  newy=xNew<IssmDouble>(newnumberofvertices);//just the new partition
3924  for(int i=0;i<newnumberofvertices;i++){//just the new partition
3925  Vertex* vertex=(Vertex*)newfemmodel_vertices->GetObjectByOffset(i);
3926  /*Attention: no spherical coordinates*/
3927  newx[i]=vertex->GetX();
3928  newy[i]=vertex->GetY();
3929  }
3930 
3931  /*Get spcvx and spcvy of old mesh*/
3932  for(int i=0;i<this->constraints_list[analysis_index]->Size();i++){
3933 
3934  Constraint* constraint=(Constraint*)this->constraints_list[analysis_index]->GetObjectByOffset(i);
3935 
3936  SpcStatic* spcstatic = xDynamicCast<SpcStatic*>(constraint);
3937  int dof = spcstatic->GetDof();
3938  int node = spcstatic->GetNodeId();
3939  IssmDouble spcvalue = spcstatic->GetValue();
3940  int nodeindex = node-1;
3941 
3942  /*vx and vx flag insertion*/
3943  if(dof==0) {//vx
3944  vspc->SetValue(nodeindex*numberofcols,spcvalue,INS_VAL); //vx
3945  vspc->SetValue(nodeindex*numberofcols+dofpernode,1,INS_VAL);//vxflag
3946  }
3947  /*vy and vy flag insertion*/
3948  if(dof==1){//vy
3949  vspc->SetValue(nodeindex*numberofcols+1,spcvalue,INS_VAL); //vy
3950  vspc->SetValue(nodeindex*numberofcols+dofpernode+1,1,INS_VAL);//vyflag
3951  }
3952  }
3953 
3954  /*Assemble and serialize*/
3955  vspc->Assemble();
3956  spc=vspc->ToMPISerial();
3957 
3958  /*Interpolate spc values and flags in the new partition*/
3959  InterpFromMeshToMesh2dx(&newspc,elementslist,x,y,numberofvertices,numberofelements,
3960  spc,numberofvertices,numberofcols,
3961  newx,newy,newnumberofvertices,NULL);
3962 
3963  /*Now, insert the interpolated constraints in the data set (constraints)*/
3964  count=0;
3965  for(int i=0;i<newnumberofvertices;i++){//just in the new partition
3966  Vertex* vertex=(Vertex*)newfemmodel_vertices->GetObjectByOffset(i);
3967  /*spcvx*/
3968  if(!xIsNan<IssmDouble>(newspc[i*numberofcols]) && newspc[i*numberofcols+dofpernode]>(1-eps)){
3969  newfemmodel_constraints->AddObject(new SpcStatic(count+1,vertex->Sid()+1,0,newspc[i*numberofcols],analysis_enum));
3970  //add count'th spc, on node i+1, setting dof 1 to vx.
3971  count++;
3972  }
3973  }
3974  count=0;
3975  for(int i=0;i<newnumberofvertices;i++){//just in the new partition
3976  Vertex* vertex=(Vertex*)newfemmodel_vertices->GetObjectByOffset(i);
3977  /*spcvy*/
3978  if(!xIsNan<IssmDouble>(newspc[i*numberofcols+1]) && newspc[i*numberofcols+dofpernode+1]>(1-eps) ){
3979  newfemmodel_constraints->AddObject(new SpcStatic(count+1,vertex->Sid()+1,1,newspc[i*numberofcols+1],analysis_enum));
3980  //add count'th spc, on node i+1, setting dof 1 to vx.
3981  count++;
3982  }
3983  }
3984 
3985  /*Cleanup*/
3986  xDelete<IssmDouble>(spc);
3987  xDelete<IssmDouble>(newspc);
3988  xDelete<IssmDouble>(newx);
3989  xDelete<IssmDouble>(newy);
3990  delete vspc;
3991 }

◆ GetInputs()

void FemModel::GetInputs ( int *  pnumP0inputs,
IssmDouble **  pP0inputs,
int **  pP0input_enums,
int **  pP0input_interp,
int *  pnumP1inputs,
IssmDouble **  pP1inputs,
int **  pP1input_enums,
int **  pP1input_interp 
)

Definition at line 3368 of file FemModel.cpp.

3368  {/*{{{*/
3369 
3370  int numberofvertices = this->vertices->NumberOfVertices();
3371  int numberofelements = this->elements->NumberOfElements();
3372  int elementswidth = this->GetElementsWidth();
3373  int numinputs,numP0inputs,numP1inputs;
3374  IssmDouble* P0inputs = NULL;
3375  Vector<IssmDouble>* vP0inputs = NULL;
3376  int* P0input_enums = NULL;
3377  int* P0input_interp = NULL;
3378  IssmDouble* P1inputs = NULL;
3379  Vector<IssmDouble>* vP1inputs = NULL;
3380  int* P1input_enums = NULL;
3381  int* P1input_interp = NULL;
3382  int* input_interpolations = NULL;
3383  int* input_enums = NULL;
3384  int* pos = NULL;
3385  IssmDouble value = 0;
3386 
3387  /*Figure out how many inputs we have and their respective interpolation*/
3388  this->inputs2->GetInputsInterpolations(&numinputs,&input_interpolations,&input_enums);
3389 
3390  /*Count and get enums of all inputs in old mesh*/
3391  for(int step=0;step<2;step++){
3392  if(step){
3393  P0input_enums = xNew<int>(numP0inputs);
3394  P0input_interp = xNew<int>(numP0inputs);
3395  P1input_enums = xNew<int>(numP1inputs);
3396  P1input_interp = xNew<int>(numP1inputs);
3397  }
3398  numP0inputs = 0;
3399  numP1inputs = 0;
3400  for(int i=0;i<numinputs;i++){
3401  int inputinterp = input_interpolations[i];
3402  switch(inputinterp){
3403  case 0:
3404  /*Input not found, go to the next*/
3405  break;
3406  case P1Enum:
3407  if(step){
3408  P1input_enums[numP1inputs] = input_enums[i];
3409  P1input_interp[numP1inputs] = inputinterp;
3410  }
3411  numP1inputs++;
3412  break;
3413  case P0Enum:
3414  case IntInput2Enum:
3415  case BoolInput2Enum:
3416  if(step){
3417  P0input_enums[numP0inputs] = input_enums[i];
3418  P0input_interp[numP0inputs] = inputinterp;
3419  }
3420  numP0inputs++;
3421  break;
3422  default:
3423  _error_(EnumToStringx(inputinterp)<<" ("<<inputinterp<<") Not supported yet");
3424  }
3425  }
3426  }
3427 
3428  /*Get P0 and P1 inputs over the elements*/
3429  pos = xNew<int>(elementswidth);
3430  vP0inputs= new Vector<IssmDouble>(numberofelements*numP0inputs);
3431  vP1inputs= new Vector<IssmDouble>(numberofvertices*numP1inputs);
3432  for(int i=0;i<this->elements->Size();i++){
3433  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
3434 
3435  /*Get P0 inputs*/
3436  for(int j=0;j<numP0inputs;j++){
3437  switch(P0input_interp[j]){
3438  case P0Enum:{
3439  Input2* input=element->GetInput2(P0input_enums[j]);
3440  input->GetInputAverage(&value);
3441  }
3442  break;
3443  case IntInput2Enum:{
3444  int valueint;
3445  element->GetInput2Value(&valueint,P0input_enums[j]);
3446  value = reCast<IssmDouble>(valueint);
3447  }
3448  break;
3449  case BoolInput2Enum:{
3450  bool valuebool;
3451  element->GetInput2Value(&valuebool,P0input_enums[j]);
3452  value = reCast<IssmDouble>(valuebool);
3453  }
3454  break;
3455  default:
3456  _error_(EnumToStringx(P0input_interp[j])<<" ("<<P0input_interp[j]<<") Not supported yet");
3457  }
3458  pos[0]=element->Sid()*numP0inputs+j;
3459  /*Insert input in the vector*/
3460  vP0inputs->SetValues(1,pos,&value,INS_VAL);
3461  }
3462 
3463  /*Get P1 inputs*/
3464  for(int j=0;j<numP1inputs;j++){
3465  Input2* temp = element->GetInput2(P1input_enums[j]); _assert_(temp);
3466  ElementInput2* input=xDynamicCast<ElementInput2*>(temp);
3467  pos[0]=element->vertices[0]->Sid()*numP1inputs+j;
3468  pos[1]=element->vertices[1]->Sid()*numP1inputs+j;
3469  pos[2]=element->vertices[2]->Sid()*numP1inputs+j;
3470  /*Insert input in the vector*/
3471  vP1inputs->SetValues(elementswidth,pos,input->element_values,INS_VAL);
3472  }
3473  }
3474 
3475  /*Assemble and serialize*/
3476  vP0inputs->Assemble();
3477  vP1inputs->Assemble();
3478  P0inputs=vP0inputs->ToMPISerial();
3479  P1inputs=vP1inputs->ToMPISerial();
3480 
3481  /*Assign pointers*/
3482  *pnumP0inputs = numP0inputs;
3483  *pP0inputs = P0inputs;
3484  *pP0input_enums = P0input_enums;
3485  *pP0input_interp = P0input_interp;
3486  *pnumP1inputs = numP1inputs;
3487  *pP1inputs = P1inputs;
3488  *pP1input_enums = P1input_enums;
3489  *pP1input_interp = P1input_interp;
3490 
3491  /*Cleanup*/
3492  delete vP0inputs;
3493  delete vP1inputs;
3494  xDelete<int>(input_interpolations);
3495  xDelete<int>(input_enums);
3496  xDelete<int>(pos);
3497 }

◆ InterpolateInputs()

void FemModel::InterpolateInputs ( Vertices *  newfemmodel_vertices,
Elements *  newfemmodel_elements,
Inputs2 *  new_inputs 
)

Definition at line 3499 of file FemModel.cpp.

3499  {/*{{{*/
3500 
3501  int numberofelements = -1; //global, entire old mesh
3502  int newnumberofelements = newfemmodel_elements->Size(); //just on the new partition
3503  int numberofvertices = -1; //global, entire old mesh
3504  int newnumberofvertices = newfemmodel_vertices->Size(); //just on the new partition
3505  int elementswidth = this->GetElementsWidth(); //just tria in this version
3506  int numP0inputs = -1;
3507  IssmDouble* P0inputs = NULL; //global, entire old mesh
3508  IssmDouble* newP0inputs = NULL; //just on the new partition
3509  int* P0input_enums = NULL;
3510  int* P0input_interp = NULL;
3511  int numP1inputs = -1;
3512  IssmDouble* P1inputs = NULL; //global, entire old mesh
3513  IssmDouble* newP1inputs = NULL; //just on the new partition
3514  int* P1input_enums = NULL;
3515  int* P1input_interp = NULL;
3516  IssmDouble* values = NULL;
3517  IssmDouble* vector = NULL;
3518  IssmDouble* x = NULL;//global, entire old mesh
3519  IssmDouble* y = NULL;//global, entire old mesh
3520  int* elementslist = NULL;//global, entire old mesh
3521  IssmDouble* newx = NULL;//just on the new partition
3522  IssmDouble* newy = NULL;//just on the new partition
3523  IssmDouble* newz = NULL;//just on the new partition
3524  IssmDouble* newxc = NULL;//just on the new partition
3525  IssmDouble* newyc = NULL;//just on the new partition
3526  int* newelementslist = NULL;//just on the new partition
3527  int* sidtoindex = NULL;//global vertices sid to partition index
3528 
3529  /*Get old P0 and P1 inputs (entire mesh)*/
3530  this->GetInputs(&numP0inputs,&P0inputs,&P0input_enums,&P0input_interp,&numP1inputs,&P1inputs,&P1input_enums,&P1input_interp);
3531 
3532  /*Get the old mesh (global, entire mesh)*/
3533  this->GetMesh(&elementslist,&x,&y,&numberofvertices,&numberofelements);
3534 
3535  /*Get the new mesh (just on the new partition)*/
3536  this->GetMeshOnPartition(newfemmodel_vertices,newfemmodel_elements,&newx,&newy,&newz,&newelementslist,&sidtoindex);
3537 
3538  /*Calculate the center points xc and xy (new mesh, new partition)*/
3539  newxc=xNewZeroInit<IssmDouble>(newnumberofelements);
3540  newyc=xNewZeroInit<IssmDouble>(newnumberofelements);
3541  for(int i=0;i<newnumberofelements;i++){
3542  for(int j=0;j<elementswidth;j++){
3543  int vid = newelementslist[i*elementswidth+j]-1;//Transform to C indexing
3544  newxc[i]+=newx[vid]/elementswidth;
3545  newyc[i]+=newy[vid]/elementswidth;
3546  }
3547  }
3548 
3549  /*Interplate P0 inputs in the new mesh (just on the new partition)*/
3550  InterpFromMeshToMesh2dx(&newP0inputs,elementslist,x,y,numberofvertices,numberofelements,
3551  P0inputs,numberofelements,numP0inputs,
3552  newxc,newyc,newnumberofelements,NULL);
3553 
3554  /*Interpolate P1 inputs in the new mesh (just on the new partition)*/
3555  InterpFromMeshToMesh2dx(&newP1inputs,elementslist,x,y,numberofvertices,numberofelements,
3556  P1inputs,numberofvertices,numP1inputs,
3557  newx,newy,newnumberofvertices,NULL);
3558 
3559  /*Insert P0 and P1 inputs into the new elements (just on the new partition)*/
3560  int vertexlids[3];
3561  values=xNew<IssmDouble>(elementswidth);
3562  for(int i=0;i<newfemmodel_elements->Size();i++){//just on the new partition
3563  Element* element=xDynamicCast<Element*>(newfemmodel_elements->GetObjectByOffset(i));
3564  /*newP0inputs is just on the new partition*/
3565  for(int j=0;j<numP0inputs;j++){
3566  switch(P0input_interp[j]){
3567  case P0Enum:
3568  element->SetElementInput(newinputs2,P0input_enums[j],newP0inputs[i*numP0inputs+j]);
3569  break;
3570  case IntInput2Enum:
3571  element->SetIntInput(newinputs2,P0input_enums[j],reCast<int>(newP0inputs[i*numP0inputs+j]));
3572  break;
3573  case BoolInput2Enum:
3574  element->SetBoolInput(newinputs2,P0input_enums[j],reCast<bool>(newP0inputs[i*numP0inputs+j]));
3575  break;
3576  default:
3577  _error_(EnumToStringx(P0input_interp[j])<<" Not supported yet");
3578  }
3579  }
3580  /*newP1inputs is just on the new partition*/
3581  for(int i=0;i<3;i++) vertexlids[i]=element->vertices[i]->lid;
3582  for(int j=0;j<numP1inputs;j++){
3583  values[0]=newP1inputs[sidtoindex[element->vertices[0]->Sid()]*numP1inputs+j];
3584  values[1]=newP1inputs[sidtoindex[element->vertices[1]->Sid()]*numP1inputs+j];
3585  values[2]=newP1inputs[sidtoindex[element->vertices[2]->Sid()]*numP1inputs+j];
3586  newinputs2->SetTriaInput(P1input_enums[j],P1Enum,3,vertexlids,values);
3587  }
3588  }
3589 
3590 
3591  /*Cleanup*/
3592  xDelete<IssmDouble>(P0inputs);
3593  xDelete<IssmDouble>(newP0inputs);
3594  xDelete<int>(P0input_enums);
3595  xDelete<int>(P0input_interp);
3596  xDelete<IssmDouble>(P1inputs);
3597  xDelete<IssmDouble>(newP1inputs);
3598  xDelete<int>(P1input_enums);
3599  xDelete<int>(P1input_interp);
3600  xDelete<IssmDouble>(newx);
3601  xDelete<IssmDouble>(newy);
3602  xDelete<IssmDouble>(newz);
3603  xDelete<IssmDouble>(newxc);
3604  xDelete<IssmDouble>(newyc);
3605  xDelete<int>(newelementslist);
3606  xDelete<int>(sidtoindex);
3607  xDelete<IssmDouble>(values);
3608 }

◆ UpdateElements()

void FemModel::UpdateElements ( int  newnumberofelements,
int *  newelementslist,
bool *  my_elements,
int  analysis_counter,
Elements *  newelements 
)

Definition at line 3993 of file FemModel.cpp.

3993  {/*{{{*/
3994 
3995  /*newelementslist is in Matlab indexing*/
3996 
3997  /*Update elements, set hnode.
3998  This code is in all analysis */
3999  int elemcounter=0;
4000  for(int iel=0;iel<newnumberofelements;iel++){
4001  if(my_elements[iel]){
4002  Tria* tria=(Tria*)newelements->GetObjectByOffset(elemcounter);
4003  //element update
4004  tria->element_type_list[analysis_counter]=P1Enum;
4005  int numnodes=3;
4006  int* tria_node_ids=xNew<int>(numnodes);
4007  tria_node_ids[0]=newelementslist[3*iel+0]; //matlab indexing
4008  tria_node_ids[1]=newelementslist[3*iel+1]; //matlab indexing
4009  tria_node_ids[2]=newelementslist[3*iel+2]; //matlab indexing
4010  tria->SetHookNodes(tria_node_ids,numnodes,analysis_counter); tria->nodes=NULL;
4011  xDelete<int>(tria_node_ids);
4012  elemcounter++;
4013  }
4014  }
4015  return;
4016 }

◆ WriteMeshInResults()

void FemModel::WriteMeshInResults ( void  )

Definition at line 3610 of file FemModel.cpp.

3610  {/*{{{*/
3611 
3612  /*Write the erros estimators*/
3613  this->WriteErrorEstimatorsInResults();
3614 
3615  int step = -1;
3616  int numberofelements = -1;
3617  int numberofvertices = -1;
3618  IssmDouble time = -1;
3619  IssmDouble* x = NULL;
3620  IssmDouble* y = NULL;
3621  int* elementslist = NULL;
3622 
3623  if(!this->elements || !this->vertices || !this->results || !this->parameters) return;
3624 
3625  parameters->FindParam(&step,StepEnum);
3626  parameters->FindParam(&time,TimeEnum);
3627 
3628  /*Get mesh. Elementslist comes in Matlab indexing*/
3629  this->GetMesh(&elementslist,&x,&y,&numberofvertices,&numberofelements);
3630 
3631  /*Write mesh in Results*/
3632  this->results->AddResult(new GenericExternalResult<int*>(this->results->Size()+1,MeshElementsEnum,
3633  elementslist,numberofelements,this->GetElementsWidth(),step,time));
3634 
3635  this->results->AddResult(new GenericExternalResult<IssmDouble*>(this->results->Size()+1,MeshXEnum,
3636  x,numberofvertices,1,step,time));
3637 
3638  this->results->AddResult(new GenericExternalResult<IssmDouble*>(this->results->Size()+1,MeshYEnum,
3639  y,numberofvertices,1,step,time));
3640 }

◆ WriteErrorEstimatorsInResults()

void FemModel::WriteErrorEstimatorsInResults ( void  )

Definition at line 3642 of file FemModel.cpp.

3642  {/*{{{*/
3643 
3644  int step = -1;
3645  int numberofelements = -1;
3646  IssmDouble time = -1;
3647  IssmDouble* stresserror = NULL;
3648  IssmDouble* thicknesserror = NULL;
3649 
3650  if(!this->elements || !this->vertices || !this->results || !this->parameters) return;
3651 
3652  parameters->FindParam(&step,StepEnum);
3653  parameters->FindParam(&time,TimeEnum);
3654  numberofelements=this->elements->NumberOfElements();
3655 
3656  /*Compute the deviatoric stress tensor*/
3657  this->ZZErrorEstimator(&stresserror);
3658 
3659  /*Compute the thickness error*/
3660  this->ThicknessZZErrorEstimator(&thicknesserror);
3661 
3662  /*Write error estimators in Results*/
3663  this->results->AddResult(new GenericExternalResult<IssmDouble*>(this->results->Size()+1,DeviatoricStressErrorEstimatorEnum,
3664  stresserror,numberofelements,1,step,time));
3665 
3666  this->results->AddResult(new GenericExternalResult<IssmDouble*>(this->results->Size()+1,ThicknessErrorEstimatorEnum,
3667  thicknesserror,numberofelements,1,step,time));
3668  /*Cleanup*/
3669  xDelete<IssmDouble>(stresserror);
3670  xDelete<IssmDouble>(thicknesserror);
3671 
3672  return;
3673 }

◆ SmoothedDeviatoricStressTensor()

void FemModel::SmoothedDeviatoricStressTensor ( IssmDouble **  ptauxx,
IssmDouble **  ptauyy,
IssmDouble **  ptauxy 
)

Definition at line 4018 of file FemModel.cpp.

4018  {/*{{{*/
4019 
4020  int elementswidth = this->GetElementsWidth();//just 2D mesh, tria elements
4021  int numberofvertices = this->vertices->NumberOfVertices();
4022  IssmDouble weight = 0.;
4023  IssmDouble* tauxx = NULL;
4024  IssmDouble* tauyy = NULL;
4025  IssmDouble* tauxy = NULL;
4026  IssmDouble* totalweight = NULL;
4027  IssmDouble* deviatoricstressxx = xNew<IssmDouble>(elementswidth);
4028  IssmDouble* deviatoricstressyy = xNew<IssmDouble>(elementswidth);
4029  IssmDouble* deviatoricstressxy = xNew<IssmDouble>(elementswidth);
4030  int* elem_vertices = xNew<int>(elementswidth);
4031  Vector<IssmDouble>* vectauxx = new Vector<IssmDouble>(numberofvertices);
4032  Vector<IssmDouble>* vectauyy = new Vector<IssmDouble>(numberofvertices);
4033  Vector<IssmDouble>* vectauxy = new Vector<IssmDouble>(numberofvertices);
4034  Vector<IssmDouble>* vectotalweight = new Vector<IssmDouble>(numberofvertices);
4035 
4036  /*Update the Deviatoric Stress tensor over the elements*/
4037  this->DeviatoricStressx();
4038 
4039  /*Calculate the Smoothed Deviatoric Stress tensor*/
4040  for(int i=0;i<this->elements->Size();i++){
4041  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
4042  element->GetInputListOnVertices(deviatoricstressxx,DeviatoricStressxxEnum);
4043  element->GetInputListOnVertices(deviatoricstressyy,DeviatoricStressyyEnum);
4044  element->GetInputListOnVertices(deviatoricstressxy,DeviatoricStressxyEnum);
4045  element->GetVerticesSidList(elem_vertices);
4046 
4047  /*weight to calculate the smoothed deviatoric stress*/
4048  Tria* triaelement = xDynamicCast<Tria*>(element);
4049  weight = triaelement->GetArea();//the tria area is a choice for the weight
4050 
4051  /*taux xx*/
4052  vectauxx->SetValue(elem_vertices[0],weight*deviatoricstressxx[0],ADD_VAL);
4053  vectauxx->SetValue(elem_vertices[1],weight*deviatoricstressxx[1],ADD_VAL);
4054  vectauxx->SetValue(elem_vertices[2],weight*deviatoricstressxx[2],ADD_VAL);
4055  /*tau yy*/
4056  vectauyy->SetValue(elem_vertices[0],weight*deviatoricstressyy[0],ADD_VAL);
4057  vectauyy->SetValue(elem_vertices[1],weight*deviatoricstressyy[1],ADD_VAL);
4058  vectauyy->SetValue(elem_vertices[2],weight*deviatoricstressyy[2],ADD_VAL);
4059  /*tau xy*/
4060  vectauxy->SetValue(elem_vertices[0],weight*deviatoricstressxy[0],ADD_VAL);
4061  vectauxy->SetValue(elem_vertices[1],weight*deviatoricstressxy[1],ADD_VAL);
4062  vectauxy->SetValue(elem_vertices[2],weight*deviatoricstressxy[2],ADD_VAL);
4063  /*total weight*/
4064  vectotalweight->SetValue(elem_vertices[0],weight,ADD_VAL);
4065  vectotalweight->SetValue(elem_vertices[1],weight,ADD_VAL);
4066  vectotalweight->SetValue(elem_vertices[2],weight,ADD_VAL);
4067  }
4068 
4069  /*Assemble*/
4070  vectauxx->Assemble();
4071  vectauyy->Assemble();
4072  vectauxy->Assemble();
4073  vectotalweight->Assemble();
4074 
4075  /*Serialize*/
4076  tauxx = vectauxx->ToMPISerial();
4077  tauyy = vectauyy->ToMPISerial();
4078  tauxy = vectauxy->ToMPISerial();
4079  totalweight = vectotalweight->ToMPISerial();
4080 
4081  /*Divide for the total weight*/
4082  for(int i=0;i<numberofvertices;i++){
4083  _assert_(totalweight[i]>0);
4084  tauxx[i] = tauxx[i]/totalweight[i];
4085  tauyy[i] = tauyy[i]/totalweight[i];
4086  tauxy[i] = tauxy[i]/totalweight[i];
4087  }
4088 
4089  /*Set output*/
4090  (*ptauxx) = tauxx;
4091  (*ptauyy) = tauyy;
4092  (*ptauxy) = tauxy;
4093 
4094  /*Cleanup*/
4095  delete vectauxx;
4096  delete vectauyy;
4097  delete vectauxy;
4098  delete vectotalweight;
4099  xDelete<IssmDouble>(deviatoricstressxx);
4100  xDelete<IssmDouble>(deviatoricstressyy);
4101  xDelete<IssmDouble>(deviatoricstressxy);
4102  xDelete<IssmDouble>(totalweight);
4103  xDelete<int>(elem_vertices);
4104 }

◆ ZZErrorEstimator()

void FemModel::ZZErrorEstimator ( IssmDouble **  pelementerror)

Definition at line 4106 of file FemModel.cpp.

4106  {/*{{{*/
4107 
4108  /*Compute the Zienkiewicz and Zhu (ZZ) error estimator for the deviatoric stress tensor.
4109  * Ref.: Zienkiewicz and Zhu, A Simple Error Estimator and Adaptive Procedure for Practical Engineering Analysis, Int. J. Numer. Meth. Eng, 1987*/
4110 
4111  IssmDouble Jdet,error,ftxx,ftyy,ftxy;
4112  int sid;
4113  int numnodes = this->GetElementsWidth();//just 2D mesh, tria elements, P1
4114  int numberofelements = this->elements->NumberOfElements();
4115  IssmDouble* xyz_list = NULL;
4116  IssmDouble* smoothedtauxx = NULL;
4117  IssmDouble* smoothedtauyy = NULL;
4118  IssmDouble* smoothedtauxy = NULL;
4119  IssmDouble* tauxx = xNew<IssmDouble>(numnodes);
4120  IssmDouble* tauyy = xNew<IssmDouble>(numnodes);
4121  IssmDouble* tauxy = xNew<IssmDouble>(numnodes);
4122  IssmDouble* basis = xNew<IssmDouble>(numnodes);
4123  int* elem_vertices = xNew<int>(numnodes);
4124  Vector<IssmDouble>* velementerror= new Vector<IssmDouble>(numberofelements);
4125 
4126  /*Get smoothed deviatoric stress tensor*/
4127  this->SmoothedDeviatoricStressTensor(&smoothedtauxx,&smoothedtauyy,&smoothedtauxy);
4128 
4129  /*Integrate the error over elements*/
4130  for(int i=0;i<this->elements->Size();i++){
4131  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
4132  element->GetInputListOnVertices(tauxx,DeviatoricStressxxEnum);
4133  element->GetInputListOnVertices(tauyy,DeviatoricStressyyEnum);
4134  element->GetInputListOnVertices(tauxy,DeviatoricStressxyEnum);
4135  element->GetVerticesSidList(elem_vertices);
4136 
4137  /*Integrate*/
4138  element->GetVerticesCoordinates(&xyz_list);
4139  Gauss* gauss=element->NewGauss(2);
4140  error=0.;
4141  for(int ig=gauss->begin();ig<gauss->end();ig++){
4142  gauss->GaussPoint(ig);
4143  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
4144  element->NodalFunctions(basis,gauss);
4145  ftxx=0;ftyy=0;ftxy=0;
4146  for(int n=0;n<numnodes;n++) {
4147  ftxx+=(tauxx[n]-smoothedtauxx[elem_vertices[n]])*basis[n];
4148  ftyy+=(tauyy[n]-smoothedtauyy[elem_vertices[n]])*basis[n];
4149  ftxy+=(tauxy[n]-smoothedtauxy[elem_vertices[n]])*basis[n];
4150  }
4151  error+=Jdet*gauss->weight*( pow(ftxx,2)+pow(ftyy,2)+pow(ftxy,2) ); //e^2
4152  }
4153  /*Set the error in the global vector*/
4154  sid=element->Sid();
4155  error = sqrt(error);//sqrt(e^2)
4156  velementerror->SetValue(sid,error,INS_VAL);
4157  /*Cleanup intermediaries*/
4158  xDelete<IssmDouble>(xyz_list);
4159  delete gauss;
4160  }
4161 
4162  /*Assemble*/
4163  velementerror->Assemble();
4164 
4165  /*Serialize and set output*/
4166  (*pelementerror)=velementerror->ToMPISerial();
4167 
4168  /*Cleanup*/
4169  xDelete<IssmDouble>(smoothedtauxx);
4170  xDelete<IssmDouble>(smoothedtauyy);
4171  xDelete<IssmDouble>(smoothedtauxy);
4172  xDelete<IssmDouble>(tauxx);
4173  xDelete<IssmDouble>(tauyy);
4174  xDelete<IssmDouble>(tauxy);
4175  xDelete<IssmDouble>(basis);
4176  xDelete<int>(elem_vertices);
4177  delete velementerror;
4178 }

◆ SmoothedGradThickness()

void FemModel::SmoothedGradThickness ( IssmDouble **  pdHdx,
IssmDouble **  pdHdy 
)

Definition at line 4180 of file FemModel.cpp.

4180  {/*{{{*/
4181 
4182  int elementswidth = this->GetElementsWidth();//just 2D mesh, tria elements
4183  int numberofvertices = this->vertices->NumberOfVertices();
4184 
4185  IssmDouble weight = 0.;
4186  IssmDouble* dHdx = NULL;
4187  IssmDouble* dHdy = NULL;
4188  IssmDouble* totalweight = NULL;
4189  IssmDouble* xyz_list = NULL;
4190  IssmDouble* H = xNew<IssmDouble>(elementswidth);
4191  IssmDouble* GradH = xNew<IssmDouble>(2);
4192  int* elem_vertices = xNew<int>(elementswidth);
4193  Vector<IssmDouble>* vecdHdx = new Vector<IssmDouble>(numberofvertices);
4194  Vector<IssmDouble>* vecdHdy = new Vector<IssmDouble>(numberofvertices);
4195  Vector<IssmDouble>* vectotalweight = new Vector<IssmDouble>(numberofvertices);
4196 
4197  for(int i=0;i<this->elements->Size();i++){
4198  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
4199  element->GetInputListOnVertices(H,ThicknessEnum);
4200  element->GetVerticesSidList(elem_vertices);
4201  element->GetVerticesCoordinates(&xyz_list);
4202 
4203  /*Get the gradient of thickness at the center point (in fact, GradH is constante over the element)*/
4204  Gauss* gauss=element->NewGauss(1);
4205  gauss->GaussPoint(gauss->begin());
4206  element->ValueP1DerivativesOnGauss(GradH,H,xyz_list,gauss);
4207 
4208  /*weight to calculate the smoothed grad H*/
4209  Tria* triaelement = xDynamicCast<Tria*>(element);
4210  weight = triaelement->GetArea();//the tria area is a choice for the weight
4211 
4212  /*dH/dx*/
4213  vecdHdx->SetValue(elem_vertices[0],weight*GradH[0],ADD_VAL);
4214  vecdHdx->SetValue(elem_vertices[1],weight*GradH[0],ADD_VAL);
4215  vecdHdx->SetValue(elem_vertices[2],weight*GradH[0],ADD_VAL);
4216  /*dH/dy*/
4217  vecdHdy->SetValue(elem_vertices[0],weight*GradH[1],ADD_VAL);
4218  vecdHdy->SetValue(elem_vertices[1],weight*GradH[1],ADD_VAL);
4219  vecdHdy->SetValue(elem_vertices[2],weight*GradH[1],ADD_VAL);
4220  /*total weight*/
4221  vectotalweight->SetValue(elem_vertices[0],weight,ADD_VAL);
4222  vectotalweight->SetValue(elem_vertices[1],weight,ADD_VAL);
4223  vectotalweight->SetValue(elem_vertices[2],weight,ADD_VAL);
4224  /*Cleanup intermediaries*/
4225  xDelete<IssmDouble>(xyz_list);
4226  delete gauss;
4227  }
4228 
4229  /*Assemble*/
4230  vecdHdx->Assemble();
4231  vecdHdy->Assemble();
4232  vectotalweight->Assemble();
4233 
4234  /*Serialize*/
4235  dHdx = vecdHdx->ToMPISerial();
4236  dHdy = vecdHdy->ToMPISerial();
4237  totalweight = vectotalweight->ToMPISerial();
4238 
4239  /*Divide for the total weight*/
4240  for(int i=0;i<numberofvertices;i++){
4241  _assert_(totalweight[i]>0);
4242  dHdx[i] = dHdx[i]/totalweight[i];
4243  dHdy[i] = dHdy[i]/totalweight[i];
4244  }
4245 
4246  /*Set output*/
4247  (*pdHdx) = dHdx;
4248  (*pdHdy) = dHdy;
4249 
4250  /*Cleanup*/
4251  delete vecdHdx;
4252  delete vecdHdy;
4253  delete vectotalweight;
4254  xDelete<IssmDouble>(H);
4255  xDelete<IssmDouble>(GradH);
4256  xDelete<IssmDouble>(totalweight);
4257  xDelete<int>(elem_vertices);
4258 }

◆ ThicknessZZErrorEstimator()

void FemModel::ThicknessZZErrorEstimator ( IssmDouble **  pelementerror)

Definition at line 4260 of file FemModel.cpp.

4260  {/*{{{*/
4261  /*Compute the Zienkiewicz and Zhu (ZZ) error estimator for the thickness
4262  * Ref.: Zienkiewicz and Zhu, A Simple Error Estimator and Adaptive Procedure for Practical Engineering Analysis, Int. J. Numer. Meth. Eng, 1987*/
4263 
4264  IssmDouble Jdet,error,fdHdx,fdHdy;
4265  int sid;
4266  int numnodes = this->GetElementsWidth();//just 2D mesh, tria elements, P1
4267  int numberofelements = this->elements->NumberOfElements();
4268  IssmDouble* xyz_list = NULL;
4269  IssmDouble* smoothed_dHdx = NULL;
4270  IssmDouble* smoothed_dHdy = NULL;
4271  IssmDouble* H = xNew<IssmDouble>(numnodes);
4272  IssmDouble* GradH = xNew<IssmDouble>(2);
4273  IssmDouble* basis = xNew<IssmDouble>(numnodes);
4274  int* elem_vertices = xNew<int>(numnodes);
4275  Vector<IssmDouble>* velementerror= new Vector<IssmDouble>(numberofelements);
4276 
4277  /*Get smoothed deviatoric stress tensor*/
4278  this->SmoothedGradThickness(&smoothed_dHdx,&smoothed_dHdy);
4279 
4280  /*Integrate the error over elements*/
4281  for(int i=0;i<this->elements->Size();i++){
4282  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
4283  element->GetInputListOnVertices(H,ThicknessEnum);
4284  element->GetVerticesSidList(elem_vertices);
4285  element->GetVerticesCoordinates(&xyz_list);
4286  /*Get the gradient of thickness*/
4287  Gauss* gaussH=element->NewGauss(1);
4288  gaussH->GaussPoint(gaussH->begin());
4289  element->ValueP1DerivativesOnGauss(GradH,H,xyz_list,gaussH);
4290  /*Integrate*/
4291  Gauss* gauss=element->NewGauss(2);
4292  error=0.;
4293  for(int ig=gauss->begin();ig<gauss->end();ig++){
4294  gauss->GaussPoint(ig);
4295  element->JacobianDeterminant(&Jdet,xyz_list,gauss);
4296  element->NodalFunctions(basis,gauss);
4297  fdHdx=0;fdHdy=0;
4298  for(int n=0;n<numnodes;n++) {
4299  fdHdx+=(GradH[0]-smoothed_dHdx[elem_vertices[n]])*basis[n];
4300  fdHdy+=(GradH[1]-smoothed_dHdy[elem_vertices[n]])*basis[n];
4301  }
4302  error+=Jdet*gauss->weight*(pow(fdHdx,2)+pow(fdHdy,2) ); //e^2
4303  }
4304  /*Set the error in the global vector*/
4305  sid=element->Sid();
4306  error = sqrt(error); //sqrt( e^2 )
4307  velementerror->SetValue(sid,error,INS_VAL);
4308  /*Cleanup intermediaries*/
4309  xDelete<IssmDouble>(xyz_list);
4310  delete gaussH;
4311  delete gauss;
4312  }
4313 
4314  /*Assemble*/
4315  velementerror->Assemble();
4316 
4317  /*Serialize and set output*/
4318  (*pelementerror)=velementerror->ToMPISerial();
4319 
4320  /*Cleanup*/
4321  xDelete<IssmDouble>(smoothed_dHdx);
4322  xDelete<IssmDouble>(smoothed_dHdy);
4323  xDelete<IssmDouble>(H);
4324  xDelete<IssmDouble>(GradH);
4325  xDelete<IssmDouble>(basis);
4326  xDelete<int>(elem_vertices);
4327  delete velementerror;
4328 }

◆ MeanGroundedIceLevelSet()

void FemModel::MeanGroundedIceLevelSet ( IssmDouble **  pmasklevelset)

Definition at line 4330 of file FemModel.cpp.

4330  {/*{{{*/
4331 
4332  int elementswidth = this->GetElementsWidth();
4333  int numberofelements = this->elements->NumberOfElements();
4334  IssmDouble* elementlevelset = xNew<IssmDouble>(elementswidth);
4335  Vector<IssmDouble>* vmasklevelset = new Vector<IssmDouble>(numberofelements);
4336 
4337  for(int i=0;i<this->elements->Size();i++){
4338  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
4339  element->GetInputListOnVertices(elementlevelset,MaskOceanLevelsetEnum);
4340  int sid = element->Sid();
4341  vmasklevelset->SetValue(sid,(elementlevelset[0]+elementlevelset[1]+elementlevelset[2])/3.,INS_VAL);
4342  }
4343 
4344  /*Assemble*/
4345  vmasklevelset->Assemble();
4346 
4347  /*Serialize and set output*/
4348  (*pmasklevelset)=vmasklevelset->ToMPISerial();
4349 
4350  /*Cleanup*/
4351  xDelete<IssmDouble>(elementlevelset);
4352  delete vmasklevelset;
4353 }

◆ GetElementCenterCoordinates()

void FemModel::GetElementCenterCoordinates ( IssmDouble **  pxc,
IssmDouble **  pyc 
)

Definition at line 4355 of file FemModel.cpp.

4355  {/*{{{*/
4356 
4357  /*Intermediaries*/
4358  int elementswidth = this->GetElementsWidth();
4359  int numberofelements = this->elements->NumberOfElements();
4360  int* elem_vertices = xNew<int>(elementswidth);
4361  Vector<IssmDouble>* vxc = new Vector<IssmDouble>(numberofelements);
4362  Vector<IssmDouble>* vyc = new Vector<IssmDouble>(numberofelements);
4363  IssmDouble* x = NULL;
4364  IssmDouble* y = NULL;
4365  IssmDouble* z = NULL;
4366  IssmDouble* xyz_list = NULL;
4367  IssmDouble x1,y1,x2,y2,x3,y3;
4368 
4369  /*Insert the element center coordinates*/
4370  for(int i=0;i<this->elements->Size();i++){
4371  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
4372  //element->GetVerticesSidList(elem_vertices);
4373  int sid = element->Sid();
4374  element->GetVerticesCoordinates(&xyz_list);
4375  x1 = xyz_list[3*0+0];y1 = xyz_list[3*0+1];
4376  x2 = xyz_list[3*1+0];y2 = xyz_list[3*1+1];
4377  x3 = xyz_list[3*2+0];y3 = xyz_list[3*2+1];
4378  vxc->SetValue(sid,(x1+x2+x3)/3.,INS_VAL);
4379  vyc->SetValue(sid,(y1+y2+y3)/3.,INS_VAL);
4380  }
4381 
4382  /*Assemble*/
4383  vxc->Assemble();
4384  vyc->Assemble();
4385 
4386  /*Serialize and set output*/
4387  (*pxc)=vxc->ToMPISerial();
4388  (*pyc)=vyc->ToMPISerial();
4389 
4390  /*Cleanup*/
4391  xDelete<IssmDouble>(x);
4392  xDelete<IssmDouble>(y);
4393  xDelete<IssmDouble>(z);
4394  xDelete<IssmDouble>(xyz_list);
4395  xDelete<int>(elem_vertices);
4396  delete vxc;
4397  delete vyc;
4398 }

◆ GetZeroLevelSetPoints()

void FemModel::GetZeroLevelSetPoints ( IssmDouble **  pzerolevelset_points,
int &  numberofpoints,
int  levelset_type 
)

Definition at line 4400 of file FemModel.cpp.

4400  {/*{{{*/
4401 
4402  /*Here, "zero level set" means grounding line or ice front, depending on the level set type*/
4403  /*pzerolevelset_points are the element center points with zero level set. X and Y coords*/
4404  if(levelset_type!=MaskOceanLevelsetEnum && levelset_type!=MaskIceLevelsetEnum){
4405  _error_("level set type not implemented yet!");
4406  }
4407 
4408  /*Outputs*/
4409  IssmDouble* zerolevelset_points = NULL;
4410  int npoints = 0;
4411 
4412  /*Intermediaries*/
4413  int elementswidth = this->GetElementsWidth();
4414  int numberofelements = this->elements->NumberOfElements();
4415  int* elem_vertices = xNew<int>(elementswidth);
4416  IssmDouble* levelset = xNew<IssmDouble>(elementswidth);
4417  IssmDouble* xyz_list = NULL;
4418  Vector<IssmDouble>* vx_zerolevelset = new Vector<IssmDouble>(numberofelements);
4419  Vector<IssmDouble>* vy_zerolevelset = new Vector<IssmDouble>(numberofelements);
4420  IssmDouble* x_zerolevelset = NULL;
4421  IssmDouble* y_zerolevelset = NULL;
4422  int count,sid;
4423  IssmDouble xc,yc,x1,y1,x2,y2,x3,y3;
4424 
4425  /*Use the element center coordinate if level set is zero (grounding line or ice front), otherwise set NAN*/
4426  for(int i=0;i<this->elements->Size();i++){
4427  Element* element=xDynamicCast<Element*>(this->elements->GetObjectByOffset(i));
4428  element->GetInputListOnVertices(levelset,levelset_type);
4429  element->GetVerticesSidList(elem_vertices);
4430  sid= element->Sid();
4431  element->GetVerticesCoordinates(&xyz_list);
4432  x1 = xyz_list[3*0+0];y1 = xyz_list[3*0+1];
4433  x2 = xyz_list[3*1+0];y2 = xyz_list[3*1+1];
4434  x3 = xyz_list[3*2+0];y3 = xyz_list[3*2+1];
4435  xc = NAN;
4436  yc = NAN;
4437  Tria* tria = xDynamicCast<Tria*>(element);
4438  if(tria->IsIceInElement()){/*verify if there is ice in the element*/
4439  if(levelset[0]*levelset[1]<0. || levelset[0]*levelset[2]<0. ||
4440  abs(levelset[0]*levelset[1])<DBL_EPSILON || abs(levelset[0]*levelset[2])<DBL_EPSILON) {
4441  xc=(x1+x2+x3)/3.;
4442  yc=(y1+y2+y3)/3.;
4443  }
4444  }
4445  vx_zerolevelset->SetValue(sid,xc,INS_VAL);
4446  vy_zerolevelset->SetValue(sid,yc,INS_VAL);
4447  xDelete<IssmDouble>(xyz_list);
4448  }
4449  /*Assemble and serialize*/
4450  vx_zerolevelset->Assemble();
4451  vy_zerolevelset->Assemble();
4452  x_zerolevelset=vx_zerolevelset->ToMPISerial();
4453  y_zerolevelset=vy_zerolevelset->ToMPISerial();
4454 
4455  /*Find the number of points*/
4456  npoints=0;
4457  for(int i=0;i<numberofelements;i++) if(!xIsNan<IssmDouble>(x_zerolevelset[i])) npoints++;
4458 
4459  /*Keep just the element center coordinates with zero level set (compact the structure)*/
4460  zerolevelset_points=xNew<IssmDouble>(2*npoints);//x and y
4461  count=0;
4462  for(int i=0;i<numberofelements;i++){
4463  if(!xIsNan<IssmDouble>(x_zerolevelset[i])){
4464  zerolevelset_points[2*count] = x_zerolevelset[i];
4465  zerolevelset_points[2*count+1] = y_zerolevelset[i];
4466  count++;
4467  }
4468  }
4469 
4470  /*Assign outputs*/
4471  numberofpoints = npoints;
4472  (*pzerolevelset_points) = zerolevelset_points;
4473 
4474  /*Cleanup*/
4475  xDelete<int>(elem_vertices);
4476  xDelete<IssmDouble>(levelset);
4477  xDelete<IssmDouble>(x_zerolevelset);
4478  xDelete<IssmDouble>(y_zerolevelset);
4479  xDelete<IssmDouble>(xyz_list);
4480  delete vx_zerolevelset;
4481  delete vy_zerolevelset;
4482 }

Field Documentation

◆ analysis_counter

int FemModel::analysis_counter

Definition at line 37 of file FemModel.h.

◆ analysis_type_list

int* FemModel::analysis_type_list

Definition at line 38 of file FemModel.h.

◆ nummodels

int FemModel::nummodels

Definition at line 39 of file FemModel.h.

◆ solution_type

int FemModel::solution_type

Definition at line 40 of file FemModel.h.

◆ profiler

Profiler* FemModel::profiler

Definition at line 42 of file FemModel.h.

◆ elements

Elements* FemModel::elements

Definition at line 44 of file FemModel.h.

◆ materials

Materials* FemModel::materials

Definition at line 45 of file FemModel.h.

◆ parameters

Parameters* FemModel::parameters

Definition at line 46 of file FemModel.h.

◆ inputs2

Inputs2* FemModel::inputs2

Definition at line 47 of file FemModel.h.

◆ results

Results* FemModel::results

Definition at line 48 of file FemModel.h.

◆ vertices

Vertices* FemModel::vertices

Definition at line 49 of file FemModel.h.

◆ constraints

Constraints* FemModel::constraints

Definition at line 52 of file FemModel.h.

◆ constraints_list

Constraints** FemModel::constraints_list

Definition at line 53 of file FemModel.h.

◆ loads

Loads* FemModel::loads

Definition at line 54 of file FemModel.h.

◆ loads_list

Loads** FemModel::loads_list

Definition at line 55 of file FemModel.h.

◆ nodes

Nodes* FemModel::nodes

Definition at line 56 of file FemModel.h.

◆ nodes_list

Nodes** FemModel::nodes_list

Definition at line 57 of file FemModel.h.

The documentation for this class was generated from the following files:
AmrNeopzEnum
@ AmrNeopzEnum
Definition: EnumDefinitions.h:975
DataSet::Size
int Size()
Definition: DataSet.cpp:399
FreeSurfaceTopAnalysisEnum
@ FreeSurfaceTopAnalysisEnum
Definition: EnumDefinitions.h:1072
Tria::iscollapsed
int iscollapsed
Definition: Tria.h:32
IceVolumeAboveFloatationScaledEnum
@ IceVolumeAboveFloatationScaledEnum
Definition: EnumDefinitions.h:1113
BalancethicknessAnalysisEnum
@ BalancethicknessAnalysisEnum
Definition: EnumDefinitions.h:981
SOLVER
#define SOLVER
Definition: Profiler.h:16
HydrologySolutionEnum
@ HydrologySolutionEnum
Definition: EnumDefinitions.h:1105
FemModel::TotalCalvingFluxLevelsetx
void TotalCalvingFluxLevelsetx(IssmDouble *pGbmb, bool scaled)
Definition: FemModel.cpp:2929
FrictionCoefficientEnum
@ FrictionCoefficientEnum
Definition: EnumDefinitions.h:574
FemModel::MaxAbsVzx
void MaxAbsVzx(IssmDouble *presponse)
Definition: FemModel.cpp:1811
DamageDOldEnum
@ DamageDOldEnum
Definition: EnumDefinitions.h:517
Element::TotalFloatingBmb
IssmDouble TotalFloatingBmb(IssmDouble *mask, bool scaled)
Definition: Element.cpp:4260
FemModel::AnalysisIndex
int AnalysisIndex(int)
Definition: FemModel.cpp:220
depthaverage_core
void depthaverage_core(FemModel *femmodel)
Definition: depthaverage_core.cpp:12
Vertices::NumberOfVerticesLocal
int NumberOfVerticesLocal(void)
Definition: Vertices.cpp:258
Profiler::TotalTimeModSec
int TotalTimeModSec(int tag)
Definition: Profiler.cpp:123
NewDamageEnum
@ NewDamageEnum
Definition: EnumDefinitions.h:658
Element::lid
int lid
Definition: Element.h:46
Vertices::Copy
Vertices * Copy()
Definition: Vertices.cpp:57
Vertices::common_recv
int * common_recv
Definition: Vertices.h:22
BaseEnum
@ BaseEnum
Definition: EnumDefinitions.h:495
Vertices
Declaration of Vertices class.
Definition: Vertices.h:15
EnthalpyAnalysisEnum
@ EnthalpyAnalysisEnum
Definition: EnumDefinitions.h:1052
Element::SetIntInput
void SetIntInput(Inputs2 *inputs2, int enum_in, int value)
Definition: Element.cpp:3362
Loads::ResetHooks
void ResetHooks()
Definition: Loads.cpp:164
SmbMassBalanceEnum
@ SmbMassBalanceEnum
Definition: EnumDefinitions.h:748
Channel
Definition: Channel.h:18
FemModel::CreateElements
void CreateElements(int newnumberofelements, int elementswidth, int *newelementslist, bool *my_elements, Elements *elements)
Definition: FemModel.cpp:3675
LoveAnalysisEnum
@ LoveAnalysisEnum
Definition: EnumDefinitions.h:1146
Profiler::Memory
IssmPDouble Memory(int tag)
Definition: Profiler.cpp:129
Element::ComputeStrainRate
void ComputeStrainRate()
Definition: Element.cpp:244
Element::GetInputListOnNodes
void GetInputListOnNodes(IssmDouble *pvalue, int enumtype)
Definition: Element.cpp:1106
SmbAnalysisEnum
@ SmbAnalysisEnum
Definition: EnumDefinitions.h:1274
FemModel::ElementOperationx
void ElementOperationx(void(Element::*function)(void))
Definition: FemModel.cpp:1243
FemModel::InitFromFiles
void InitFromFiles(char *rootpath, char *inputfilename, char *outputfilename, char *petscfilename, char *lockfilename, char *restartfilename, const int solution_type, bool trace, IssmPDouble *X=NULL)
Definition: FemModel.cpp:393
Vertex::z
IssmDouble z
Definition: Vertex.h:30
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
FemModel::vertices
Vertices * vertices
Definition: FemModel.h:49
IndexEnum
@ IndexEnum
Definition: EnumDefinitions.h:201
Balancethickness2SolutionEnum
@ Balancethickness2SolutionEnum
Definition: EnumDefinitions.h:980
IssmDouble
double IssmDouble
Definition: types.h:37
IceVolumeScaledEnum
@ IceVolumeScaledEnum
Definition: EnumDefinitions.h:1115
GetMaskOfIceVerticesLSMx0
void GetMaskOfIceVerticesLSMx0(FemModel *femmodel)
Definition: SetActiveNodesLSMx.cpp:59
FemModel::MaxVelx
void MaxVelx(IssmDouble *presponse)
Definition: FemModel.cpp:1855
Element::IsOnBase
bool IsOnBase()
Definition: Element.cpp:1984
Nodes
Declaration of Nodes class.
Definition: Nodes.h:19
InputToDepthaverageOutEnum
@ InputToDepthaverageOutEnum
Definition: EnumDefinitions.h:204
AutodiffDependentObjectsEnum
@ AutodiffDependentObjectsEnum
Definition: EnumDefinitions.h:43
DatasetInput2
Definition: DatasetInput2.h:14
Element::GetIcefrontArea
virtual IssmDouble GetIcefrontArea()
Definition: Element.h:248
FrontalForcingsBasinIcefrontAreaEnum
@ FrontalForcingsBasinIcefrontAreaEnum
Definition: EnumDefinitions.h:152
Element::GetNumberOfNodes
virtual int GetNumberOfNodes(void)=0
InversionNumControlParametersEnum
@ InversionNumControlParametersEnum
Definition: EnumDefinitions.h:223
FemModel::MaxAbsVyx
void MaxAbsVyx(IssmDouble *presponse)
Definition: FemModel.cpp:1786
ExtrudeFromBaseAnalysisEnum
@ ExtrudeFromBaseAnalysisEnum
Definition: EnumDefinitions.h:1058
MasstransportAnalysisEnum
@ MasstransportAnalysisEnum
Definition: EnumDefinitions.h:1163
Vertices::common_send
int * common_send
Definition: Vertices.h:24
BalancevelocityAnalysisEnum
@ BalancevelocityAnalysisEnum
Definition: EnumDefinitions.h:987
_printf0_
#define _printf0_(StreamArgs)
Definition: Print.h:29
ISSM_MPI_Allreduce
int ISSM_MPI_Allreduce(void *sendbuf, void *recvbuf, int count, ISSM_MPI_Datatype datatype, ISSM_MPI_Op op, ISSM_MPI_Comm comm)
Definition: issmmpi.cpp:116
Gradient2Enum
@ Gradient2Enum
Definition: EnumDefinitions.h:1087
Element::FindParam
void FindParam(bool *pvalue, int paramenum)
Definition: Element.cpp:933
ElementHook::SetHookNodes
void SetHookNodes(int *node_ids, int numnodes, int analysis_counter)
Definition: ElementHook.cpp:188
Element::SetBoolInput
void SetBoolInput(Inputs2 *inputs2, int enum_in, bool value)
Definition: Element.cpp:3355
Profiler::TotalFlops
IssmPDouble TotalFlops(int tag)
Definition: Profiler.cpp:87
MeshElementsEnum
@ MeshElementsEnum
Definition: EnumDefinitions.h:1183
GroundinglineMassFluxEnum
@ GroundinglineMassFluxEnum
Definition: EnumDefinitions.h:1092
StressbalanceAnalysisEnum
@ StressbalanceAnalysisEnum
Definition: EnumDefinitions.h:1285
BasalforcingsEnum
@ BasalforcingsEnum
Definition: EnumDefinitions.h:64
FloatingAreaScaledEnum
@ FloatingAreaScaledEnum
Definition: EnumDefinitions.h:1068
BalancethicknessThickeningRateEnum
@ BalancethicknessThickeningRateEnum
Definition: EnumDefinitions.h:474
RestartFileNameEnum
@ RestartFileNameEnum
Definition: EnumDefinitions.h:299
StepEnum
@ StepEnum
Definition: EnumDefinitions.h:403
Parameters::Exist
bool Exist(int enum_type)
Definition: Parameters.cpp:254
FemModel::MinVyx
void MinVyx(IssmDouble *presponse)
Definition: FemModel.cpp:2005
HydrologydcEnum
@ HydrologydcEnum
Definition: EnumDefinitions.h:1106
DebugProfilingEnum
@ DebugProfilingEnum
Definition: EnumDefinitions.h:122
TransientInput2::Configure
void Configure(Parameters *params)
Definition: TransientInput2.cpp:104
DataSet::AddObject
int AddObject(Object *object)
Definition: DataSet.cpp:252
Nodes::common_send
int * common_send
Definition: Nodes.h:28
FlowequationIsSSAEnum
@ FlowequationIsSSAEnum
Definition: EnumDefinitions.h:142
_printf_
#define _printf_(StreamArgs)
Definition: Print.h:22
HydrologydcMaskEplactiveNodeEnum
@ HydrologydcMaskEplactiveNodeEnum
Definition: EnumDefinitions.h:608
BalancethicknessMisfitEnum
@ BalancethicknessMisfitEnum
Definition: EnumDefinitions.h:471
InversionControlParametersEnum
@ InversionControlParametersEnum
Definition: EnumDefinitions.h:209
TotalFloatingBmbScaledEnum
@ TotalFloatingBmbScaledEnum
Definition: EnumDefinitions.h:1308
MinVyEnum
@ MinVyEnum
Definition: EnumDefinitions.h:1188
FemModel::nummodels
int nummodels
Definition: FemModel.h:39
MaskOceanLevelsetEnum
@ MaskOceanLevelsetEnum
Definition: EnumDefinitions.h:640
Balancethickness2AnalysisEnum
@ Balancethickness2AnalysisEnum
Definition: EnumDefinitions.h:979
FemModel::BalancethicknessMisfitx
void BalancethicknessMisfitx(IssmDouble *pV)
Definition: FemModel.cpp:962
InversionCostFunctionsCoefficientsEnum
@ InversionCostFunctionsCoefficientsEnum
Definition: EnumDefinitions.h:629
Parameters
Declaration of Parameters class.
Definition: Parameters.h:18
ExtrudeFromTopAnalysisEnum
@ ExtrudeFromTopAnalysisEnum
Definition: EnumDefinitions.h:1059
FemModel::EtaDiffx
void EtaDiffx(IssmDouble *pJ)
Definition: FemModel.cpp:2112
TransientSolutionEnum
@ TransientSolutionEnum
Definition: EnumDefinitions.h:1317
MaskIceLevelsetEnum
@ MaskIceLevelsetEnum
Definition: EnumDefinitions.h:641
VerboseMProcessor
bool VerboseMProcessor(void)
Definition: Verbosity.cpp:22
ISSM_MPI_SUM
#define ISSM_MPI_SUM
Definition: issmmpi.h:134
BalancethicknessSoftSolutionEnum
@ BalancethicknessSoftSolutionEnum
Definition: EnumDefinitions.h:984
FemModel::parameters
Parameters * parameters
Definition: FemModel.h:46
Vertex::clone
bool clone
Definition: Vertex.h:22
TimeEnum
@ TimeEnum
Definition: EnumDefinitions.h:427
ADD_VAL
@ ADD_VAL
Definition: toolkitsenums.h:14
CreateVertices
void CreateVertices(Elements *elements, Vertices *vertices, IoModel *iomodel, int solution_type, bool isamr)
Definition: CreateElementsVerticesAndMaterials.cpp:301
MARSHALLING_ENUM
#define MARSHALLING_ENUM(EN)
Definition: Marshalling.h:14
IssmComm::GetComm
static ISSM_MPI_Comm GetComm(void)
Definition: IssmComm.cpp:30
DepthAverageAnalysisEnum
@ DepthAverageAnalysisEnum
Definition: EnumDefinitions.h:1036
DeviatoricStressxxEnum
@ DeviatoricStressxxEnum
Definition: EnumDefinitions.h:524
BalancevelocitySolutionEnum
@ BalancevelocitySolutionEnum
Definition: EnumDefinitions.h:988
Constraints
Declaration of Constraints class.
Definition: Constraints.h:13
DamageEvolutionAnalysisEnum
@ DamageEvolutionAnalysisEnum
Definition: EnumDefinitions.h:1026
BedEnum
@ BedEnum
Definition: EnumDefinitions.h:499
Element::SpawnBasalElement
virtual Element * SpawnBasalElement(void)=0
P0Enum
@ P0Enum
Definition: EnumDefinitions.h:661
TransientInput2
Definition: TransientInput2.h:13
HydrologydcMaskThawedNodeEnum
@ HydrologydcMaskThawedNodeEnum
Definition: EnumDefinitions.h:610
OutputFileNameEnum
@ OutputFileNameEnum
Definition: EnumDefinitions.h:283
FemModel::Size
int Size(void)
Definition: FemModel.cpp:638
Element::IceVolumeAboveFloatation
IssmDouble IceVolumeAboveFloatation(IssmDouble *mask, bool scaled)
Definition: Element.cpp:1607
Element::CalvingRateVonmises
virtual void CalvingRateVonmises(void)
Definition: Element.h:221
Element::ResultToVector
void ResultToVector(Vector< IssmDouble > *vector, int output_enum)
Definition: Element.cpp:3299
GROUNDINGLINECORE
#define GROUNDINGLINECORE
Definition: Profiler.h:25
ToolkitsOptionsFromAnalysis
void ToolkitsOptionsFromAnalysis(Parameters *parameters, int analysis_type)
Element::TimeAdapt
virtual IssmDouble TimeAdapt()=0
Element::MassFlux
virtual IssmDouble MassFlux(IssmDouble *segment)=0
MARSHALLING_SIZE
@ MARSHALLING_SIZE
Definition: Marshalling.h:11
Nodes::NumberOfNodesLocalAll
int NumberOfNodesLocalAll(void)
Definition: Nodes.cpp:364
FemModel::GetMeshOnPartition
void GetMeshOnPartition(Vertices *femmodel_vertices, Elements *femmodel_elements, IssmDouble **px, IssmDouble **py, IssmDouble **pz, int **pelementslist, int **psidtoindex)
Definition: FemModel.cpp:3837
Elements
Declaration of Elements class.
Definition: Elements.h:17
GetVectorFromInputsx
void GetVectorFromInputsx(IssmDouble **pvector, int *pvector_size, FemModel *femmodel, int name)
Definition: GetVectorFromInputsx.cpp:81
ThicknessAbsMisfitx
void ThicknessAbsMisfitx(IssmDouble *pJ, Elements *elements, Nodes *nodes, Vertices *vertices, Loads *loads, Materials *materials, Parameters *parameters)
Definition: ThicknessAbsMisfitx.cpp:11
FemModel::SolutionAnalysesList
void SolutionAnalysesList(int **panalyses, int *pnumanalyses, IoModel *iomodel, int solutiontype)
Definition: FemModel.cpp:646
FemModel::results
Results * results
Definition: FemModel.h:48
Vertices::NumberOfVertices
int NumberOfVertices(void)
Definition: Vertices.cpp:255
Vector::GetLocalVector
void GetLocalVector(doubletype **pvector, int **pindices)
Definition: Vector.h:219
BalancethicknessSolutionEnum
@ BalancethicknessSolutionEnum
Definition: EnumDefinitions.h:985
ISSM_MPI_MAX
#define ISSM_MPI_MAX
Definition: issmmpi.h:131
TotalSmbScaledEnum
@ TotalSmbScaledEnum
Definition: EnumDefinitions.h:1312
MaterialsRhoIceEnum
@ MaterialsRhoIceEnum
Definition: EnumDefinitions.h:264
MismipFloatingMeltRateEnum
@ MismipFloatingMeltRateEnum
Definition: EnumDefinitions.h:1190
SpcStatic::GetValue
IssmDouble GetValue()
Definition: SpcStatic.cpp:164
CORE
#define CORE
Definition: Profiler.h:15
Gradient1Enum
@ Gradient1Enum
Definition: EnumDefinitions.h:1086
Element::GroundedArea
IssmDouble GroundedArea(IssmDouble *mask, bool scaled)
Definition: Element.cpp:1548
P1DGEnum
@ P1DGEnum
Definition: EnumDefinitions.h:1215
Node::clone
bool clone
Definition: Node.h:27
ThicknessPositiveEnum
@ ThicknessPositiveEnum
Definition: EnumDefinitions.h:842
Element::vertices
Vertex ** vertices
Definition: Element.h:49
FemModel::TotalCalvingMeltingFluxLevelsetx
void TotalCalvingMeltingFluxLevelsetx(IssmDouble *pGbmb, bool scaled)
Definition: FemModel.cpp:2945
SurfaceRelVelMisfitEnum
@ SurfaceRelVelMisfitEnum
Definition: EnumDefinitions.h:828
Element::WriteFieldIsovalueSegment
virtual void WriteFieldIsovalueSegment(DataSet *segments, int fieldenum, IssmDouble fieldvalue)
Definition: Element.h:366
FreeSurfaceBaseAnalysisEnum
@ FreeSurfaceBaseAnalysisEnum
Definition: EnumDefinitions.h:1071
DamageEvolutionSolutionEnum
@ DamageEvolutionSolutionEnum
Definition: EnumDefinitions.h:1027
HydrologyShaktiAnalysisEnum
@ HydrologyShaktiAnalysisEnum
Definition: EnumDefinitions.h:1103
AnalysisCounterEnum
@ AnalysisCounterEnum
Definition: EnumDefinitions.h:35
SpcStatic::GetNodeId
int GetNodeId()
Definition: SpcStatic.cpp:159
IoModel::my_elements
bool * my_elements
Definition: IoModel.h:66
BasalforcingsPicoEnum
@ BasalforcingsPicoEnum
Definition: EnumDefinitions.h:990
pfopen
FILE * pfopen(char *filename, const char *format, bool errorout=true)
Definition: pfopen.cpp:30
EsaAnalysisEnum
@ EsaAnalysisEnum
Definition: EnumDefinitions.h:1053
MasstransportStabilizationEnum
@ MasstransportStabilizationEnum
Definition: EnumDefinitions.h:249
Element::StrainRateparallel
virtual void StrainRateparallel(void)=0
Nodes::common_recv_ids
int ** common_recv_ids
Definition: Nodes.h:27
FemModel::AdjustBaseThicknessAndMask
void AdjustBaseThicknessAndMask(void)
Definition: FemModel.cpp:3314
Contour
Definition: Contour.h:15
Vertex::x
IssmDouble x
Definition: Vertex.h:28
Outputdefinition100Enum
@ Outputdefinition100Enum
Definition: EnumDefinitions.h:964
HydrologyPismAnalysisEnum
@ HydrologyPismAnalysisEnum
Definition: EnumDefinitions.h:1102
FemModel::Marshall
void Marshall(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
Definition: FemModel.cpp:464
Element::TotalCalvingFluxLevelset
virtual IssmDouble TotalCalvingFluxLevelset(bool scaled)
Definition: Element.h:350
DeviatoricStressxyEnum
@ DeviatoricStressxyEnum
Definition: EnumDefinitions.h:525
FemModel::constraints_list
Constraints ** constraints_list
Definition: FemModel.h:53
Element::Sid
int Sid()
Definition: Element.cpp:3578
SealevelriseSolutionEnum
@ SealevelriseSolutionEnum
Definition: EnumDefinitions.h:1267
FemModel::SmoothedDeviatoricStressTensor
void SmoothedDeviatoricStressTensor(IssmDouble **ptauxx, IssmDouble **ptauyy, IssmDouble **ptauxy)
Definition: FemModel.cpp:4018
Element::ResultToPatch
void ResultToPatch(IssmDouble *values, int nodesperelement, int output_enum)
Definition: Element.cpp:3270
HydrologyDCEfficientAnalysis::HydrologyEPLGetActive
void HydrologyEPLGetActive(Vector< IssmDouble > *active_vec, Element *element)
Definition: HydrologyDCEfficientAnalysis.cpp:808
DatasetInput2::GetInputValue
void GetInputValue(IssmDouble *pvalue, Gauss *gauss, int index)
Definition: DatasetInput2.cpp:199
ExternalResult::GetValue
virtual double GetValue(void)=0
Element::ControlToVectors
virtual void ControlToVectors(Vector< IssmPDouble > *vector_control, Vector< IssmPDouble > *vector_gradient, int control_enum)=0
SettingsResultsOnNodesEnum
@ SettingsResultsOnNodesEnum
Definition: EnumDefinitions.h:338
VerboseModule
bool VerboseModule(void)
Definition: Verbosity.cpp:23
TransientIsgroundinglineEnum
@ TransientIsgroundinglineEnum
Definition: EnumDefinitions.h:447
DragCoefficientAbsGradientEnum
@ DragCoefficientAbsGradientEnum
Definition: EnumDefinitions.h:537
ConfigureObjectsx
int ConfigureObjectsx(Elements *elements, Loads *loads, Nodes *nodes, Vertices *vertices, Materials *materials, Parameters *parameters, Inputs2 *inputs2)
Definition: ConfigureObjectsx.cpp:11
Element::isonbase
bool isonbase
Definition: Element.h:53
FemModel::TotalSmbx
void TotalSmbx(IssmDouble *pSmb, bool scaled)
Definition: FemModel.cpp:2993
Vertices::common_recv_ids
int ** common_recv_ids
Definition: Vertices.h:23
VyEnum
@ VyEnum
Definition: EnumDefinitions.h:850
Nodes::Marshall
void Marshall(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
Definition: Nodes.cpp:105
Element::ComputeNewDamage
void ComputeNewDamage()
Definition: Element.cpp:144
ProfilingCurrentFlopsEnum
@ ProfilingCurrentFlopsEnum
Definition: EnumDefinitions.h:1234
Parameters::Copy
Parameters * Copy(void)
Definition: Parameters.cpp:86
Element::FloatingArea
IssmDouble FloatingArea(IssmDouble *mask, bool scaled)
Definition: Element.cpp:948
Parameters::AddObject
void AddObject(Param *newparam)
Definition: Parameters.cpp:67
SmoothAnalysisEnum
@ SmoothAnalysisEnum
Definition: EnumDefinitions.h:1276
Element::UpdateConstraintsExtrudeFromTop
virtual void UpdateConstraintsExtrudeFromTop(void)=0
Input2::GetInputMaxAbs
virtual IssmDouble GetInputMaxAbs(void)
Definition: Input2.h:35
HydrologyDCEfficientAnalysis
Definition: HydrologyDCEfficientAnalysis.h:12
SpcStatic
Definition: SpcStatic.h:13
Input2::GetInputMax
virtual IssmDouble GetInputMax(void)
Definition: Input2.h:34
SurfaceLogVxVyMisfitx
void SurfaceLogVxVyMisfitx(IssmDouble *pJ, Elements *elements, Nodes *nodes, Vertices *vertices, Loads *loads, Materials *materials, Parameters *parameters)
Definition: SurfaceLogVxVyMisfitx.cpp:11
SurfaceLogVxVyMisfitEnum
@ SurfaceLogVxVyMisfitEnum
Definition: EnumDefinitions.h:826
Loads::Copy
Loads * Copy()
Definition: Loads.cpp:42
Vertex::UpdatePosition
void UpdatePosition(Vector< IssmDouble > *vx, Vector< IssmDouble > *vy, Vector< IssmDouble > *vz, Parameters *parameters, IssmDouble *thickness, IssmDouble *bed)
Definition: Vertex.cpp:170
Input2::GetInputDerivativeValue
virtual void GetInputDerivativeValue(IssmDouble *derivativevalues, IssmDouble *xyz_list, Gauss *gauss)
Definition: Input2.h:37
ElementHook::hmaterial
Hook * hmaterial
Definition: ElementHook.h:17
HydrologyDCInefficientAnalysisEnum
@ HydrologyDCInefficientAnalysisEnum
Definition: EnumDefinitions.h:1099
TotalGroundedBmbEnum
@ TotalGroundedBmbEnum
Definition: EnumDefinitions.h:1309
FemModel::InitFromFids
void InitFromFids(char *rootpath, FILE *IOMODEL, FILE *toolkitsoptionsfid, int in_solution_type, bool trace, IssmPDouble *X=NULL)
Definition: FemModel.cpp:424
ElementInput2
Definition: ElementInput2.h:7
MaterialsRheologyBbarEnum
@ MaterialsRheologyBbarEnum
Definition: EnumDefinitions.h:644
Vertex::GetY
IssmDouble GetY(void)
Definition: Vertex.cpp:156
SurfaceAbsVelMisfitEnum
@ SurfaceAbsVelMisfitEnum
Definition: EnumDefinitions.h:818
Element::StressIntensityFactor
virtual void StressIntensityFactor(void)=0
Element::GetInput2
virtual Input2 * GetInput2(int inputenum)=0
Element::DeleteMaterials
void DeleteMaterials(void)
Definition: Element.cpp:429
pfopen0
FILE * pfopen0(char *filename, const char *format)
Definition: pfopen.cpp:16
SmbSolutionEnum
@ SmbSolutionEnum
Definition: EnumDefinitions.h:1275
FemModel::Divergencex
void Divergencex(IssmDouble *pdiv)
Definition: FemModel.cpp:1227
HydrologyGlaDSAnalysisEnum
@ HydrologyGlaDSAnalysisEnum
Definition: EnumDefinitions.h:1100
Element::nodes
Node ** nodes
Definition: Element.h:48
SpcStatic::GetDof
int GetDof()
Definition: SpcStatic.cpp:155
Element
Definition: Element.h:41
Element::NodalFunctions
virtual void NodalFunctions(IssmDouble *basis, Gauss *gauss)=0
EtaDiffEnum
@ EtaDiffEnum
Definition: EnumDefinitions.h:569
MARSHALLING_DYNAMIC
#define MARSHALLING_DYNAMIC(FIELD, TYPE, SIZE)
Definition: Marshalling.h:61
Element::IcefrontMassFlux
virtual IssmDouble IcefrontMassFlux(bool scaled)
Definition: Element.h:271
MaxVxEnum
@ MaxVxEnum
Definition: EnumDefinitions.h:1178
IoModel::numberofvertices
int numberofvertices
Definition: IoModel.h:99
P1Enum
@ P1Enum
Definition: EnumDefinitions.h:662
FemModel::OmegaAbsGradientx
void OmegaAbsGradientx(IssmDouble *pJ)
Definition: FemModel.cpp:2055
VzMeshEnum
@ VzMeshEnum
Definition: EnumDefinitions.h:856
HydrologyDCEfficientAnalysis::HydrologyEPLGetMask
void HydrologyEPLGetMask(Vector< IssmDouble > *vec_mask, Vector< IssmDouble > *recurence, Element *element)
Definition: HydrologyDCEfficientAnalysis.cpp:714
Element::GetDatasetInput2
virtual DatasetInput2 * GetDatasetInput2(int inputenum)
Definition: Element.h:250
Domain2DhorizontalEnum
@ Domain2DhorizontalEnum
Definition: EnumDefinitions.h:534
VyMeshEnum
@ VyMeshEnum
Definition: EnumDefinitions.h:851
ISSM_MPI_DOUBLE
#define ISSM_MPI_DOUBLE
Definition: issmmpi.h:125
Element::ElementResponse
virtual void ElementResponse(IssmDouble *presponse, int response_enum)=0
ThermalSolutionEnum
@ ThermalSolutionEnum
Definition: EnumDefinitions.h:1303
ChannelEnum
@ ChannelEnum
Definition: EnumDefinitions.h:1008
MeltingAnalysisEnum
@ MeltingAnalysisEnum
Definition: EnumDefinitions.h:1182
Nodes::NumberOfNodes
int NumberOfNodes(void)
Definition: Nodes.cpp:354
ExternalResult
Definition: ExternalResult.h:21
ExtrapolationAnalysisEnum
@ ExtrapolationAnalysisEnum
Definition: EnumDefinitions.h:1057
FemModel::MaxAbsVxx
void MaxAbsVxx(IssmDouble *presponse)
Definition: FemModel.cpp:1761
UzawaPressureAnalysisEnum
@ UzawaPressureAnalysisEnum
Definition: EnumDefinitions.h:1320
IoModel::AddConstant
void AddConstant(IoConstant *constant_in)
Definition: IoModel.cpp:288
Parameters::SetParam
void SetParam(bool boolean, int enum_type)
Definition: Parameters.cpp:441
LATaylorHoodEnum
@ LATaylorHoodEnum
Definition: EnumDefinitions.h:1139
ISSM_MPI_INT
#define ISSM_MPI_INT
Definition: issmmpi.h:127
BalancethicknessOmegaEnum
@ BalancethicknessOmegaEnum
Definition: EnumDefinitions.h:473
SMBCORE
#define SMBCORE
Definition: Profiler.h:24
IoModel::numberofelements
int numberofelements
Definition: IoModel.h:96
DependentObject
Definition: DependentObject.h:15
GiaSolutionEnum
@ GiaSolutionEnum
Definition: EnumDefinitions.h:1085
SurfaceAbsMisfitEnum
@ SurfaceAbsMisfitEnum
Definition: EnumDefinitions.h:817
Nodes::common_send_ids
int ** common_send_ids
Definition: Nodes.h:29
FemModel::SyncLocalVectorWithClonesVertices
void SyncLocalVectorWithClonesVertices(IssmDouble *local_vector)
Definition: FemModel.cpp:1366
Gradient3Enum
@ Gradient3Enum
Definition: EnumDefinitions.h:1088
Element::Divergence
IssmDouble Divergence(void)
Definition: Element.cpp:720
L2ProjectionBaseAnalysisEnum
@ L2ProjectionBaseAnalysisEnum
Definition: EnumDefinitions.h:1136
GiaAnalysisEnum
@ GiaAnalysisEnum
Definition: EnumDefinitions.h:1084
BasalforcingsGroundediceMeltingRateEnum
@ BasalforcingsGroundediceMeltingRateEnum
Definition: EnumDefinitions.h:478
MeshYEnum
@ MeshYEnum
Definition: EnumDefinitions.h:1185
Element::GroundinglineMassFlux
virtual IssmDouble GroundinglineMassFlux(bool scaled)
Definition: Element.h:273
Element::TotalCalvingMeltingFluxLevelset
virtual IssmDouble TotalCalvingMeltingFluxLevelset(bool scaled)
Definition: Element.h:351
Element::inputs2
Inputs2 * inputs2
Definition: Element.h:47
Materials
Declaration of Materials class.
Definition: Materials.h:16
Element::id
int id
Definition: Element.h:44
FemModel::UpdateConstraintsx
void UpdateConstraintsx(void)
Definition: FemModel.cpp:3027
Element::IceVolume
IssmDouble IceVolume(IssmDouble *mask, bool scaled)
Definition: Element.cpp:1594
Element::sid
int sid
Definition: Element.h:45
FemModel::IceVolumex
void IceVolumex(IssmDouble *pV, bool scaled)
Definition: FemModel.cpp:1687
Vector::SetValues
void SetValues(int ssize, int *list, doubletype *values, InsMode mode)
Definition: Vector.h:153
DomainTypeEnum
@ DomainTypeEnum
Definition: EnumDefinitions.h:124
Vertex::GetX
IssmDouble GetX(void)
Definition: Vertex.cpp:152
VxAverageEnum
@ VxAverageEnum
Definition: EnumDefinitions.h:845
DAMAGECORE
#define DAMAGECORE
Definition: Profiler.h:21
FemModel::nodes
Nodes * nodes
Definition: FemModel.h:56
ProfilingSolutionTimeEnum
@ ProfilingSolutionTimeEnum
Definition: EnumDefinitions.h:1236
Element::AddInput2
virtual void AddInput2(int input_enum, IssmDouble *values, int interpolation_enum)
Definition: Element.h:216
InputUpdateFromVectorx
void InputUpdateFromVectorx(FemModel *femmodel, Vector< IssmDouble > *vector, int name, int type)
Definition: InputUpdateFromVectorx.cpp:9
Element::Id
int Id()
Definition: Element.cpp:1620
HydrologyDCInefficientAnalysis::ElementizeIdsMask
void ElementizeIdsMask(FemModel *femmodel)
Definition: HydrologyDCInefficientAnalysis.cpp:816
FemModel::MinVelx
void MinVelx(IssmDouble *presponse)
Definition: FemModel.cpp:1955
Element::NewGauss
virtual Gauss * NewGauss(void)=0
FrontalForcingsNumberofBasinsEnum
@ FrontalForcingsNumberofBasinsEnum
Definition: EnumDefinitions.h:153
InversionCostFunctionsEnum
@ InversionCostFunctionsEnum
Definition: EnumDefinitions.h:211
FemModel::analysis_counter
int analysis_counter
Definition: FemModel.h:37
InputFileNameEnum
@ InputFileNameEnum
Definition: EnumDefinitions.h:202
ThicknessAlongGradientx
void ThicknessAlongGradientx(IssmDouble *pJ, Elements *elements, Nodes *nodes, Vertices *vertices, Loads *loads, Materials *materials, Parameters *parameters)
Definition: ThicknessAlongGradientx.cpp:11
Profiler
Definition: Profiler.h:33
VzEnum
@ VzEnum
Definition: EnumDefinitions.h:853
FemModel::materials
Materials * materials
Definition: FemModel.h:45
EnumToStringx
const char * EnumToStringx(int enum_in)
Definition: EnumToStringx.cpp:15
Hook
Definition: Hook.h:16
LevelsetAnalysisEnum
@ LevelsetAnalysisEnum
Definition: EnumDefinitions.h:1141
DeviatoricStressyyEnum
@ DeviatoricStressyyEnum
Definition: EnumDefinitions.h:527
Element::element_type_list
int * element_type_list
Definition: Element.h:55
FemModel::DeviatoricStressx
void DeviatoricStressx()
Definition: FemModel.cpp:1095
MaxAbsVxEnum
@ MaxAbsVxEnum
Definition: EnumDefinitions.h:1173
DomainDimensionEnum
@ DomainDimensionEnum
Definition: EnumDefinitions.h:123
FemModel::MinVxx
void MinVxx(IssmDouble *presponse)
Definition: FemModel.cpp:1980
CreateNumberNodeToElementConnectivity
void CreateNumberNodeToElementConnectivity(IoModel *iomodel)
Definition: CreateNumberNodeToElementConnectivity.cpp:16
IssmComm::GetSize
static int GetSize(void)
Definition: IssmComm.cpp:46
NodesDofx
void NodesDofx(Nodes *nodes, Parameters *parameters)
Definition: NodesDofx.cpp:10
ThicknessAlongGradientEnum
@ ThicknessAlongGradientEnum
Definition: EnumDefinitions.h:839
MinVxEnum
@ MinVxEnum
Definition: EnumDefinitions.h:1187
HydrologyDCInefficientAnalysis
Definition: HydrologyDCInefficientAnalysis.h:12
FemModel::analysis_type_list
int * analysis_type_list
Definition: FemModel.h:38
Nodes::GetLocalVectorWithClonesGset
void GetLocalVectorWithClonesGset(IssmDouble **plocal_vector, Vector< IssmDouble > *vector)
Definition: Nodes.cpp:463
IssmComm::SetComm
static void SetComm(void)
Definition: IssmComm.cpp:22
FemModel::GetElementsWidth
int GetElementsWidth()
Definition: FemModel.h:79
StressbalanceSolutionEnum
@ StressbalanceSolutionEnum
Definition: EnumDefinitions.h:1288
IoModel::FindConstant
void FindConstant(bool *pvalue, const char *constant_name)
Definition: IoModel.cpp:2362
MASSTRANSPORTCORE
#define MASSTRANSPORTCORE
Definition: Profiler.h:23
SurfaceRelVelMisfitx
void SurfaceRelVelMisfitx(IssmDouble *pJ, Elements *elements, Nodes *nodes, Vertices *vertices, Loads *loads, Materials *materials, Parameters *parameters)
Definition: SurfaceRelVelMisfitx.cpp:11
Element::TotalSmb
IssmDouble TotalSmb(IssmDouble *mask, bool scaled)
Definition: Element.cpp:4286
DamageDEnum
@ DamageDEnum
Definition: EnumDefinitions.h:516
EplZigZagCounterEnum
@ EplZigZagCounterEnum
Definition: EnumDefinitions.h:130
ToolkitsFileNameEnum
@ ToolkitsFileNameEnum
Definition: EnumDefinitions.h:438
Element::GetInput2Value
void GetInput2Value(bool *pvalue, int enum_type)
Definition: Element.cpp:1185
FemModel::TotalFloatingBmbx
void TotalFloatingBmbx(IssmDouble *pFbmb, bool scaled)
Definition: FemModel.cpp:2961
MasstransportSolutionEnum
@ MasstransportSolutionEnum
Definition: EnumDefinitions.h:1164
MOVINGFRONTCORE
#define MOVINGFRONTCORE
Definition: Profiler.h:22
FemModel::ZZErrorEstimator
void ZZErrorEstimator(IssmDouble **pelementerror)
Definition: FemModel.cpp:4106
ISSM_MPI_MIN
#define ISSM_MPI_MIN
Definition: issmmpi.h:132
MARSHALLING
#define MARSHALLING(FIELD)
Definition: Marshalling.h:29
OmegaAbsGradientEnum
@ OmegaAbsGradientEnum
Definition: EnumDefinitions.h:660
Element::GetVerticesCoordinates
void GetVerticesCoordinates(IssmDouble **xyz_list)
Definition: Element.cpp:1446
SurfaceAbsVelMisfitx
void SurfaceAbsVelMisfitx(IssmDouble *pJ, Elements *elements, Nodes *nodes, Vertices *vertices, Loads *loads, Materials *materials, Parameters *parameters)
Definition: SurfaceAbsVelMisfitx.cpp:11
Inputs2::ChangeEnum
void ChangeEnum(int enumtype, int new_enumtype)
Definition: Inputs2.cpp:170
FemModel::MaxVyx
void MaxVyx(IssmDouble *presponse)
Definition: FemModel.cpp:1905
MeshElementtypeEnum
@ MeshElementtypeEnum
Definition: EnumDefinitions.h:271
Element::GetNode
Node * GetNode(int nodeindex)
Definition: Element.cpp:1207
Element::ResultToMatrix
void ResultToMatrix(IssmDouble *values, int ncols, int output_enum)
Definition: Element.cpp:3290
ISSM_MPI_Send
int ISSM_MPI_Send(void *buf, int count, ISSM_MPI_Datatype datatype, int dest, int tag, ISSM_MPI_Comm comm)
Definition: issmmpi.cpp:484
FemModel::MaxVxx
void MaxVxx(IssmDouble *presponse)
Definition: FemModel.cpp:1880
Nodes::common_recv
int * common_recv
Definition: Nodes.h:26
MPROCESSOR
#define MPROCESSOR
Definition: Profiler.h:14
Element::UpdateConstraintsExtrudeFromBase
virtual void UpdateConstraintsExtrudeFromBase(void)=0
FemModel::inputs2
Inputs2 * inputs2
Definition: FemModel.h:47
GIACORE
#define GIACORE
Definition: Profiler.h:26
MaxAbsVzEnum
@ MaxAbsVzEnum
Definition: EnumDefinitions.h:1175
FemModel::ElementResponsex
void ElementResponsex(IssmDouble *presponse, int response_enum)
Definition: FemModel.cpp:1252
Outputdefinition1Enum
@ Outputdefinition1Enum
Definition: EnumDefinitions.h:865
IceMassScaledEnum
@ IceMassScaledEnum
Definition: EnumDefinitions.h:1111
ConfigurationTypeEnum
@ ConfigurationTypeEnum
Definition: EnumDefinitions.h:101
SettingsNumResultsOnNodesEnum
@ SettingsNumResultsOnNodesEnum
Definition: EnumDefinitions.h:335
Inputs2::Copy
Inputs2 * Copy(void)
Definition: Inputs2.cpp:56
INS_VAL
@ INS_VAL
Definition: toolkitsenums.h:14
FemModel::constraints
Constraints * constraints
Definition: FemModel.h:52
AutodiffIsautodiffEnum
@ AutodiffIsautodiffEnum
Definition: EnumDefinitions.h:50
TotalCalvingMeltingFluxLevelsetEnum
@ TotalCalvingMeltingFluxLevelsetEnum
Definition: EnumDefinitions.h:1306
InputDuplicatex
void InputDuplicatex(FemModel *femmodel, int original_enum, int new_enum)
Definition: InputDuplicatex.cpp:10
SolutionTypeEnum
@ SolutionTypeEnum
Definition: EnumDefinitions.h:398
TOTAL
#define TOTAL
Definition: Profiler.h:13
ThicknessAbsMisfitEnum
@ ThicknessAbsMisfitEnum
Definition: EnumDefinitions.h:837
FemModel::GroundinglineMassFluxx
void GroundinglineMassFluxx(IssmDouble *presponse, bool scaled)
Definition: FemModel.cpp:1627
ISSM_MPI_Status
int ISSM_MPI_Status
Definition: issmmpi.h:121
IceVolumeEnum
@ IceVolumeEnum
Definition: EnumDefinitions.h:1114
SurfaceEnum
@ SurfaceEnum
Definition: EnumDefinitions.h:823
RheologyBAbsGradientx
void RheologyBAbsGradientx(IssmDouble *pJ, Elements *elements, Nodes *nodes, Vertices *vertices, Loads *loads, Materials *materials, Parameters *parameters)
Definition: RheologyBAbsGradientx.cpp:11
MaxVelEnum
@ MaxVelEnum
Definition: EnumDefinitions.h:1177
DataSet::GetEnum
int GetEnum()
Definition: DataSet.cpp:324
InversionSurfaceObsEnum
@ InversionSurfaceObsEnum
Definition: EnumDefinitions.h:630
THERMALCORE
#define THERMALCORE
Definition: Profiler.h:18
Node::IsClone
int IsClone()
Definition: Node.cpp:801
TransientAmrFrequencyEnum
@ TransientAmrFrequencyEnum
Definition: EnumDefinitions.h:442
Inputs2
Declaration of Inputs class.
Definition: Inputs2.h:23
SealevelriseAnalysisEnum
@ SealevelriseAnalysisEnum
Definition: EnumDefinitions.h:1266
NodalValuex
void NodalValuex(IssmDouble *pnodalvalue, int natureofdataenum, Elements *elements, Nodes *nodes, Vertices *vertices, Loads *loads, Materials *materials, Parameters *parameters)
Definition: NodalValuex.cpp:10
Results::AddResult
int AddResult(ExternalResult *result)
Definition: Results.cpp:33
IoModel::domaindim
int domaindim
Definition: IoModel.h:77
FemModel::loads
Loads * loads
Definition: FemModel.h:54
WrapperCorePointerFromSolutionEnum
void WrapperCorePointerFromSolutionEnum(void(**psolutioncore)(FemModel *), Parameters *parameters, int solutiontype, bool nodakotacore=false)
Definition: WrapperCorePointerFromSolutionEnum.cpp:17
MinVzEnum
@ MinVzEnum
Definition: EnumDefinitions.h:1189
Profiler::Stop
void Stop(int tagenum, bool dontmpisync=true)
Definition: Profiler.cpp:179
DivergenceEnum
@ DivergenceEnum
Definition: EnumDefinitions.h:1038
ISSM_MPI_PDOUBLE
#define ISSM_MPI_PDOUBLE
Definition: issmmpi.h:126
TransientIsthermalEnum
@ TransientIsthermalEnum
Definition: EnumDefinitions.h:455
Domain3DEnum
@ Domain3DEnum
Definition: EnumDefinitions.h:536
MaterialsRhoSeawaterEnum
@ MaterialsRhoSeawaterEnum
Definition: EnumDefinitions.h:265
FemModel::nodes_list
Nodes ** nodes_list
Definition: FemModel.h:57
FemModel::BedrockFromMismipPlus
void BedrockFromMismipPlus(void)
Definition: FemModel.cpp:3283
Contour::nods
int nods
Definition: Contour.h:20
HydrologyDCEfficientAnalysisEnum
@ HydrologyDCEfficientAnalysisEnum
Definition: EnumDefinitions.h:1098
HydrologyDCInefficientAnalysis::HydrologyIdsGetActive
void HydrologyIdsGetActive(Vector< IssmDouble > *active_vec, Element *element)
Definition: HydrologyDCInefficientAnalysis.cpp:834
FemModel::solution_type
int solution_type
Definition: FemModel.h:40
IsInputEnum
bool IsInputEnum(int enum_in)
Definition: EnumToStringx.cpp:1368
FemModel::elements
Elements * elements
Definition: FemModel.h:44
ISSM_MPI_Bcast
int ISSM_MPI_Bcast(void *buffer, int count, ISSM_MPI_Datatype datatype, int root, ISSM_MPI_Comm comm)
Definition: issmmpi.cpp:162
FemModel::Responsex
void Responsex(IssmDouble *presponse, int response_descriptor_enum)
Definition: FemModel.cpp:2558
DependentObject::Responsex
void Responsex(IssmDouble *poutput_value, FemModel *femmodel)
Definition: DependentObject.cpp:93
FemModel::TotalGroundedBmbx
void TotalGroundedBmbx(IssmDouble *pGbmb, bool scaled)
Definition: FemModel.cpp:2977
IoConstant
Definition: IoModel.h:19
HydrologyShreveAnalysisEnum
@ HydrologyShreveAnalysisEnum
Definition: EnumDefinitions.h:1104
DamageDbarOldEnum
@ DamageDbarOldEnum
Definition: EnumDefinitions.h:519
SLRCORE
#define SLRCORE
Definition: Profiler.h:28
TransientInput2::AddPentaTimeInput
void AddPentaTimeInput(IssmDouble time, int numindices, int *indices, IssmDouble *values_in, int interp_in)
Definition: TransientInput2.cpp:180
DamageDbarEnum
@ DamageDbarEnum
Definition: EnumDefinitions.h:518
Object::ObjectEnum
virtual int ObjectEnum()=0
ProcessArguments
void ProcessArguments(int *solution, char **pbinname, char **poutbinname, char **ptoolkitsname, char **plockname, char **prestartname, char **prootpath, int argc, char **argv)
Definition: ProcessArguments.cpp:10
MaxVzEnum
@ MaxVzEnum
Definition: EnumDefinitions.h:1180
Profiler::Used
bool Used(int tagenum)
Definition: Profiler.cpp:218
Vector::Assemble
void Assemble(void)
Definition: Vector.h:142
Vertices::NumberOfVerticesLocalAll
int NumberOfVerticesLocalAll(void)
Definition: Vertices.cpp:261
EnumToAnalysis
Analysis * EnumToAnalysis(int analysis_enum)
Definition: EnumToAnalysis.cpp:13
StringToEnumx
int StringToEnumx(const char *string_in, bool notfounderror=true)
Definition: StringToEnumx.cpp:14
FemModel::IceMassx
void IceMassx(IssmDouble *pV, bool scaled)
Definition: FemModel.cpp:1655
Input2
Definition: Input2.h:18
HydrologydcEplflipLockEnum
@ HydrologydcEplflipLockEnum
Definition: EnumDefinitions.h:184
FemModel::ThicknessPositivex
void ThicknessPositivex(IssmDouble *pJ)
Definition: FemModel.cpp:2837
MARSHALLING_BACKWARD
@ MARSHALLING_BACKWARD
Definition: Marshalling.h:10
RheologyBbarAbsGradientx
void RheologyBbarAbsGradientx(IssmDouble *pJ, Elements *elements, Nodes *nodes, Vertices *vertices, Loads *loads, Materials *materials, Parameters *parameters)
Definition: RheologyBbarAbsGradientx.cpp:11
FemModel
Definition: FemModel.h:31
Element::GetVerticesSidList
void GetVerticesSidList(int *sidlist)
Definition: Element.cpp:1456
FemModel::IcefrontMassFluxx
void IcefrontMassFluxx(IssmDouble *presponse, bool scaled)
Definition: FemModel.cpp:1579
VertexPIdEnum
@ VertexPIdEnum
Definition: EnumDefinitions.h:1324
Element::CreateDistanceInputFromSegmentlist
virtual void CreateDistanceInputFromSegmentlist(IssmDouble *distances, int distanceenum)
Definition: Element.h:236
FemModel::MinVzx
void MinVzx(IssmDouble *presponse)
Definition: FemModel.cpp:2030
ThermalAnalysisEnum
@ ThermalAnalysisEnum
Definition: EnumDefinitions.h:1302
Elements::ResetHooks
void ResetHooks()
Definition: Elements.cpp:78
LoveSolutionEnum
@ LoveSolutionEnum
Definition: EnumDefinitions.h:1155
LockFileNameEnum
@ LockFileNameEnum
Definition: EnumDefinitions.h:230
Element::SetElementInput
virtual void SetElementInput(int enum_in, IssmDouble values)
Definition: Element.h:333
Materials::ResetHooks
void ResetHooks()
Definition: Materials.cpp:46
SealevelEnum
@ SealevelEnum
Definition: EnumDefinitions.h:675
Matice
Definition: Matice.h:24
TotalSmbEnum
@ TotalSmbEnum
Definition: EnumDefinitions.h:1311
WriteLockFile
void WriteLockFile(char *filename)
Definition: WriteLockFile.cpp:10
DataSet::Presort
void Presort()
Definition: DataSet.cpp:368
Nodes::Copy
Nodes * Copy()
Definition: Nodes.cpp:48
Inputs2::GetTransientInput
TransientInput2 * GetTransientInput(int enum_type)
Definition: Inputs2.cpp:406
Element::ValueP1DerivativesOnGauss
virtual void ValueP1DerivativesOnGauss(IssmDouble *dvalue, IssmDouble *values, IssmDouble *xyz_list, Gauss *gauss)=0
StressbalanceSIAAnalysisEnum
@ StressbalanceSIAAnalysisEnum
Definition: EnumDefinitions.h:1287
RheologyBInitialguessMisfitx
void RheologyBInitialguessMisfitx(IssmDouble *pJ, Elements *elements, Nodes *nodes, Vertices *vertices, Loads *loads, Materials *materials, Parameters *parameters)
Definition: RheologyBAbsGradientx.cpp:82
Element::CalvingMeltingFluxLevelset
virtual void CalvingMeltingFluxLevelset(void)
Definition: Element.h:225
MaxDivergenceEnum
@ MaxDivergenceEnum
Definition: EnumDefinitions.h:1176
HydrologyshaktiEnum
@ HydrologyshaktiEnum
Definition: EnumDefinitions.h:1108
GenericExternalResult
Definition: GenericExternalResult.h:21
IssmComm::GetRank
static int GetRank(void)
Definition: IssmComm.cpp:34
LACrouzeixRaviartEnum
@ LACrouzeixRaviartEnum
Definition: EnumDefinitions.h:1138
Element::IsIceInElement
bool IsIceInElement()
Definition: Element.cpp:2021
FemModel::IceVolumeAboveFloatationx
void IceVolumeAboveFloatationx(IssmDouble *pV, bool scaled)
Definition: FemModel.cpp:1671
Loads
Declaration of Loads class.
Definition: Loads.h:16
IcefrontMassFluxLevelsetEnum
@ IcefrontMassFluxLevelsetEnum
Definition: EnumDefinitions.h:1117
DeviatoricStressErrorEstimatorEnum
@ DeviatoricStressErrorEstimatorEnum
Definition: EnumDefinitions.h:1037
L2ProjectionEPLAnalysisEnum
@ L2ProjectionEPLAnalysisEnum
Definition: EnumDefinitions.h:1137
Node
Definition: Node.h:23
Node::Lid
int Lid(void)
Definition: Node.cpp:618
InputToDepthaverageInEnum
@ InputToDepthaverageInEnum
Definition: EnumDefinitions.h:203
Node::Sid
int Sid(void)
Definition: Node.cpp:622
GLheightadvectionAnalysisEnum
@ GLheightadvectionAnalysisEnum
Definition: EnumDefinitions.h:1077
TimesteppingTimeStepMinEnum
@ TimesteppingTimeStepMinEnum
Definition: EnumDefinitions.h:435
Contour::y
doubletype * y
Definition: Contour.h:22
VerboseSolver
bool VerboseSolver(void)
Definition: Verbosity.cpp:25
StressbalanceVerticalAnalysisEnum
@ StressbalanceVerticalAnalysisEnum
Definition: EnumDefinitions.h:1289
Element::ResultInterpolation
void ResultInterpolation(int *pinterpolation, int *nodesperelement, int *parray_size, int output_enum)
Definition: Element.cpp:3162
FloatingAreaEnum
@ FloatingAreaEnum
Definition: EnumDefinitions.h:1067
FemModel::CreateMaterials
void CreateMaterials(int newnumberofelements, bool *my_elements, Materials *materials)
Definition: FemModel.cpp:3721
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
ElementHook::hvertices
Hook * hvertices
Definition: ElementHook.h:16
Node::Deactivate
void Deactivate(void)
Definition: Node.cpp:681
Tria
Definition: Tria.h:29
AmrTypeEnum
@ AmrTypeEnum
Definition: EnumDefinitions.h:34
FemModel::GetInputs
void GetInputs(int *pnumP0inputs, IssmDouble **pP0inputs, int **pP0input_enums, int **pP0input_interp, int *pnumP1inputs, IssmDouble **pP1inputs, int **pP1input_enums, int **pP1input_interp)
Definition: FemModel.cpp:3368
Parameters::Marshall
void Marshall(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
Definition: Parameters.cpp:113
FlowequationIsFSEnum
@ FlowequationIsFSEnum
Definition: EnumDefinitions.h:138
Profiler::Start
void Start(int tagenum, bool dontmpisync=true)
Definition: Profiler.cpp:139
FemModel::UpdateElements
void UpdateElements(int newnumberofelements, int *newelementslist, bool *my_elements, int analysis_counter, Elements *newelements)
Definition: FemModel.cpp:3993
Element::parameters
Parameters * parameters
Definition: Element.h:51
ChannelAreaEnum
@ ChannelAreaEnum
Definition: EnumDefinitions.h:1009
ModelProcessorx
void ModelProcessorx(Elements **pelements, Nodes ***pnodes, Vertices **pvertices, Materials **pmaterials, Constraints ***pconstraints, Loads ***ploads, Parameters **pparameters, Inputs2 **pinputs2, IoModel *iomodel, FILE *toolkitfile, char *rootpath, const int solution_enum, const int nummodels, const int *analysis_enum_list)
Definition: ModelProcessorx.cpp:15
RheologyBAbsGradientEnum
@ RheologyBAbsGradientEnum
Definition: EnumDefinitions.h:671
Gauss::begin
virtual int begin(void)=0
SurfaceSlopeSolutionEnum
@ SurfaceSlopeSolutionEnum
Definition: EnumDefinitions.h:1298
VerboseSolution
bool VerboseSolution(void)
Definition: Verbosity.cpp:24
DataSet::GetObjectByOffset
Object * GetObjectByOffset(int offset)
Definition: DataSet.cpp:334
VxEnum
@ VxEnum
Definition: EnumDefinitions.h:846
HydrologypismEnum
@ HydrologypismEnum
Definition: EnumDefinitions.h:1107
FemModel::MassFluxx
void MassFluxx(IssmDouble *presponse)
Definition: FemModel.cpp:1703
Contour::x
doubletype * x
Definition: Contour.h:21
DoubleVecParam
Definition: DoubleVecParam.h:20
EsaSolutionEnum
@ EsaSolutionEnum
Definition: EnumDefinitions.h:1054
Profiler::TotalTimeModHour
int TotalTimeModHour(int tag)
Definition: Profiler.cpp:110
BalancethicknessOmega0Enum
@ BalancethicknessOmega0Enum
Definition: EnumDefinitions.h:472
Tria::GetArea
IssmDouble GetArea(void)
Definition: Tria.cpp:1423
Element::StrainRateperpendicular
virtual void StrainRateperpendicular(void)=0
InversionNumCostFunctionsEnum
@ InversionNumCostFunctionsEnum
Definition: EnumDefinitions.h:224
MPISERIAL
#define MPISERIAL
Definition: Profiler.h:29
FemModel::CreateConstraints
void CreateConstraints(Vertices *newfemmodel_vertices, int analysis_enum, Constraints *newfemmodel_constraints)
Definition: FemModel.cpp:3894
PentaEnum
@ PentaEnum
Definition: EnumDefinitions.h:1231
SurfaceLogVelMisfitEnum
@ SurfaceLogVelMisfitEnum
Definition: EnumDefinitions.h:825
FemModel::MaxVzx
void MaxVzx(IssmDouble *presponse)
Definition: FemModel.cpp:1930
FemModelCommEnum
@ FemModelCommEnum
Definition: EnumDefinitions.h:136
OutputDefinitionsResponsex
IssmDouble OutputDefinitionsResponsex(FemModel *femmodel, int output_enum)
Definition: OutputDefinitionsResponsex.cpp:38
AmrBamgEnum
@ AmrBamgEnum
Definition: EnumDefinitions.h:974
Profiler::TotalTimeModMin
int TotalTimeModMin(int tag)
Definition: Profiler.cpp:117
Element::JacobianDeterminant
virtual void JacobianDeterminant(IssmDouble *Jdet, IssmDouble *xyz_list, Gauss *gauss)=0
Gauss::GaussPoint
virtual void GaussPoint(int ig)=0
Input2::GetInputMin
virtual IssmDouble GetInputMin(void)
Definition: Input2.h:36
Node::lid
int lid
Definition: Node.h:30
FemModel::SurfaceAbsMisfitx
void SurfaceAbsMisfitx(IssmDouble *pJ)
Definition: FemModel.cpp:2663
RootPathEnum
@ RootPathEnum
Definition: EnumDefinitions.h:301
NodeSIdEnum
@ NodeSIdEnum
Definition: EnumDefinitions.h:1200
AutodiffNumDependentsEnum
@ AutodiffNumDependentsEnum
Definition: EnumDefinitions.h:52
FemModel::RequestedOutputsx
void RequestedOutputsx(Results **presults, char **requested_outputs, int numoutputs, bool save_results=true)
Definition: FemModel.cpp:2267
StringParam
Definition: StringParam.h:20
MassFluxEnum
@ MassFluxEnum
Definition: EnumDefinitions.h:1159
FemModel::SetCurrentConfiguration
void SetCurrentConfiguration(int configuration_type)
Definition: FemModel.cpp:634
ad_core
void ad_core(FemModel *femmodel)
Definition: ad_core.cpp:24
Inputs2::SetTransientInput
void SetTransientInput(int enum_in, IssmDouble *times, int numtimes)
Definition: Inputs2.cpp:676
Vertex::lid
int lid
Definition: Vertex.h:27
Inputs2::DeleteInput
int DeleteInput(int enum_type)
Definition: Inputs2.cpp:195
VyAverageEnum
@ VyAverageEnum
Definition: EnumDefinitions.h:849
Element::CalvingFluxLevelset
virtual void CalvingFluxLevelset(void)
Definition: Element.h:224
STRESSBALANCECORE
#define STRESSBALANCECORE
Definition: Profiler.h:20
Elements::SetCurrentConfiguration
void SetCurrentConfiguration(Elements *elements, Loads *loads, Nodes *nodes, Vertices *vertices, Materials *materials, Parameters *parameters)
Definition: Elements.cpp:92
ElementHook::hneighbors
Hook * hneighbors
Definition: ElementHook.h:18
MARSHALLING_FORWARD
@ MARSHALLING_FORWARD
Definition: Marshalling.h:9
BoolInput2Enum
@ BoolInput2Enum
Definition: EnumDefinitions.h:995
Parameters::FindParam
void FindParam(bool *pinteger, int enum_type)
Definition: Parameters.cpp:262
Loads::Marshall
void Marshall(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
Definition: Loads.cpp:75
ThicknessEnum
@ ThicknessEnum
Definition: EnumDefinitions.h:840
ElementInput2::element_values
IssmDouble * element_values
Definition: ElementInput2.h:18
Vertex::y
IssmDouble y
Definition: Vertex.h:29
GroundedAreaScaledEnum
@ GroundedAreaScaledEnum
Definition: EnumDefinitions.h:1090
DataSet::Copy
DataSet * Copy(void)
Definition: DataSet.cpp:49
FemModel::FloatingAreax
void FloatingAreax(IssmDouble *pV, bool scaled)
Definition: FemModel.cpp:1292
IceVolumeAboveFloatationEnum
@ IceVolumeAboveFloatationEnum
Definition: EnumDefinitions.h:1112
Element::TotalGroundedBmb
IssmDouble TotalGroundedBmb(IssmDouble *mask, bool scaled)
Definition: Element.cpp:4273
FrontalForcingsBasinIdEnum
@ FrontalForcingsBasinIdEnum
Definition: EnumDefinitions.h:585
ThicknessErrorEstimatorEnum
@ ThicknessErrorEstimatorEnum
Definition: EnumDefinitions.h:1304
FemModel::InterpolateInputs
void InterpolateInputs(Vertices *newfemmodel_vertices, Elements *newfemmodel_elements, Inputs2 *new_inputs)
Definition: FemModel.cpp:3499
HydrologyGlaDSEnum
@ HydrologyGlaDSEnum
Definition: EnumDefinitions.h:1101
AnalysisTypeEnum
@ AnalysisTypeEnum
Definition: EnumDefinitions.h:36
VelEnum
@ VelEnum
Definition: EnumDefinitions.h:844
SpcNodesx
void SpcNodesx(Nodes *nodes, Constraints *constraints, Parameters *parameters)
Definition: SpcNodesx.cpp:10
FemModel::IcefrontMassFluxLevelsetx
void IcefrontMassFluxLevelsetx(IssmDouble *presponse, bool scaled)
Definition: FemModel.cpp:1595
MaxAbsVyEnum
@ MaxAbsVyEnum
Definition: EnumDefinitions.h:1174
Inputs2::GetInputsInterpolations
void GetInputsInterpolations(int *pnuminputs, int **pinterpolations, int **penum)
Definition: Inputs2.cpp:263
Elements::NumberOfElements
int NumberOfElements(void)
Definition: Elements.cpp:67
Vertex::GetZ
IssmDouble GetZ(void)
Definition: Vertex.cpp:160
Constraint
Definition: Constraint.h:17
Element::CreateInputTimeAverage
virtual void CreateInputTimeAverage(int transientinput_enum, int averagedinput_enum, IssmDouble init_time, IssmDouble end_time, int averaging_method)
Definition: Element.h:237
ElementHook::hnodes
Hook ** hnodes
Definition: ElementHook.h:15
DummyEnum
@ DummyEnum
Definition: EnumDefinitions.h:547
Node::ApplyConstraint
void ApplyConstraint(int dof, IssmDouble value)
Definition: Node.cpp:646
IoModel::elements
int * elements
Definition: IoModel.h:79
Element::CalvingRateLevermann
virtual void CalvingRateLevermann(void)=0
SteadystateSolutionEnum
@ SteadystateSolutionEnum
Definition: EnumDefinitions.h:1283
MaticeEnum
@ MaticeEnum
Definition: EnumDefinitions.h:1169
Input2::GetInputValue
virtual void GetInputValue(IssmDouble *pvalue, Gauss *gauss)
Definition: Input2.h:38
FemModel::ThicknessAbsGradientx
void ThicknessAbsGradientx(IssmDouble *pJ)
Definition: FemModel.cpp:2718
VertexCoordinatesx
void VertexCoordinatesx(IssmDouble **px, IssmDouble **py, IssmDouble **pz, Vertices *vertices, bool spherical)
Definition: VertexCoordinatesx.cpp:11
Vertex
Definition: Vertex.h:19
Gauss::weight
IssmDouble weight
Definition: Gauss.h:11
SurfaceAverageVelMisfitEnum
@ SurfaceAverageVelMisfitEnum
Definition: EnumDefinitions.h:821
BedSlopeSolutionEnum
@ BedSlopeSolutionEnum
Definition: EnumDefinitions.h:992
ISSM_MPI_Recv
int ISSM_MPI_Recv(void *buf, int count, ISSM_MPI_Datatype datatype, int source, int tag, ISSM_MPI_Comm comm, ISSM_MPI_Status *status)
Definition: issmmpi.cpp:342
IoModel
Definition: IoModel.h:48
P0ArrayEnum
@ P0ArrayEnum
Definition: EnumDefinitions.h:1213
IoModel::meshelementtype
int meshelementtype
Definition: IoModel.h:91
Vector::ToMPISerial
doubletype * ToMPISerial(void)
Definition: Vector.h:277
FemModel::ThicknessZZErrorEstimator
void ThicknessZZErrorEstimator(IssmDouble **pelementerror)
Definition: FemModel.cpp:4260
HydrologyDCInefficientAnalysis::ElementizeEplMask
void ElementizeEplMask(FemModel *femmodel)
Definition: HydrologyDCInefficientAnalysis.cpp:756
SurfaceLogVelMisfitx
void SurfaceLogVelMisfitx(IssmDouble *pJ, Elements *elements, Nodes *nodes, Vertices *vertices, Loads *loads, Materials *materials, Parameters *parameters)
Definition: SurfaceLogVelMisfitx.cpp:10
ADCORE
#define ADCORE
Definition: Profiler.h:17
SettingsWaitonlockEnum
@ SettingsWaitonlockEnum
Definition: EnumDefinitions.h:341
TotalCalvingFluxLevelsetEnum
@ TotalCalvingFluxLevelsetEnum
Definition: EnumDefinitions.h:1305
ISSM_MPI_Reduce
int ISSM_MPI_Reduce(void *sendbuf, void *recvbuf, int count, ISSM_MPI_Datatype datatype, ISSM_MPI_Op op, int root, ISSM_MPI_Comm comm)
Definition: issmmpi.cpp:373
Element::RignotMeltParameterization
virtual void RignotMeltParameterization(void)
Definition: Element.h:332
FemModel::loads_list
Loads ** loads_list
Definition: FemModel.h:55
max
IssmDouble max(IssmDouble a, IssmDouble b)
Definition: extrema.cpp:24
HydrologyshreveEnum
@ HydrologyshreveEnum
Definition: EnumDefinitions.h:1109
ToolkitsOptionsStringsEnum
@ ToolkitsOptionsStringsEnum
Definition: EnumDefinitions.h:440
IssmPDouble
IssmDouble IssmPDouble
Definition: types.h:38
Element::IceMass
IssmDouble IceMass(bool scaled)
Definition: Element.cpp:1569
TimesteppingTimeStepMaxEnum
@ TimesteppingTimeStepMaxEnum
Definition: EnumDefinitions.h:434
pfclose
void pfclose(FILE *fid, char *filename)
Definition: pfclose.cpp:14
DragCoefficientAbsGradientx
void DragCoefficientAbsGradientx(IssmDouble *pJ, Elements *elements, Nodes *nodes, Vertices *vertices, Loads *loads, Materials *materials, Parameters *parameters)
Definition: DragCoefficientAbsGradientx.cpp:11
IntInput2Enum
@ IntInput2Enum
Definition: EnumDefinitions.h:996
ThicknessAbsGradientEnum
@ ThicknessAbsGradientEnum
Definition: EnumDefinitions.h:836
MassFluxSegmentsPresentEnum
@ MassFluxSegmentsPresentEnum
Definition: EnumDefinitions.h:242
Element::GetNumberOfVertices
virtual int GetNumberOfVertices(void)=0
DataSet
Declaration of DataSet class.
Definition: DataSet.h:14
Channel::WriteChannelCrossSection
void WriteChannelCrossSection(IssmPDouble *values)
Definition: Channel.cpp:716
MassFluxSegmentsEnum
@ MassFluxSegmentsEnum
Definition: EnumDefinitions.h:241
FemModel::SetMesh
void SetMesh(int **elementslist, IssmDouble **x, IssmDouble **y, int *numberofvertices, int *numberofelements)
Definition: FemModel.cpp:3819
Element::GetInputListOnVertices
void GetInputListOnVertices(IssmDouble *pvalue, int enumtype)
Definition: Element.cpp:1131
IoModel::domaintype
int domaintype
Definition: IoModel.h:78
IceMassEnum
@ IceMassEnum
Definition: EnumDefinitions.h:1110
FemModel::DistanceToFieldValue
void DistanceToFieldValue(int fieldenum, IssmDouble fieldvalue, int distanceenum)
Definition: FemModel.cpp:1103
ESACORE
#define ESACORE
Definition: Profiler.h:27
Domain2DverticalEnum
@ Domain2DverticalEnum
Definition: EnumDefinitions.h:535
FemModel::SmoothedGradThickness
void SmoothedGradThickness(IssmDouble **pdHdx, IssmDouble **pdHdy)
Definition: FemModel.cpp:4180
Inputs2::Marshall
void Marshall(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
Definition: Inputs2.cpp:81
FemModel::profiler
Profiler * profiler
Definition: FemModel.h:42
Vector
Definition: Vector.h:25
Vertices::Marshall
void Marshall(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
Definition: Vertices.cpp:112
Input2::GetInputAverage
virtual void GetInputAverage(IssmDouble *pvalue)
Definition: Input2.h:33
InterpFromMeshToMesh2dx
int InterpFromMeshToMesh2dx(double **pdata_interp, int *index_data, double *x_data, double *y_data, int nods_data, int nels_data, double *data, int M_data, int N_data, double *x_interp, double *y_interp, int N_interp, Options *options)
Definition: InterpFromMeshToMesh2dx.cpp:16
Element::isonsurface
bool isonsurface
Definition: Element.h:52
Results
Declaration of Results class.
Definition: Results.h:14
HYDROLOGYCORE
#define HYDROLOGYCORE
Definition: Profiler.h:19
IcefrontMassFluxEnum
@ IcefrontMassFluxEnum
Definition: EnumDefinitions.h:1116
FlowequationIsSIAEnum
@ FlowequationIsSIAEnum
Definition: EnumDefinitions.h:141
Profiler::TotalTime
IssmPDouble TotalTime(int tag)
Definition: Profiler.cpp:96
TotalGroundedBmbScaledEnum
@ TotalGroundedBmbScaledEnum
Definition: EnumDefinitions.h:1310
FemModel::MaxDivergencex
void MaxDivergencex(IssmDouble *pdiv)
Definition: FemModel.cpp:1836
Loads::SetCurrentConfiguration
void SetCurrentConfiguration(Elements *elements, Loads *loads, Nodes *nodes, Vertices *vertices, Materials *materials, Parameters *parameters)
Definition: Loads.cpp:178
RheologyBInitialguessMisfitEnum
@ RheologyBInitialguessMisfitEnum
Definition: EnumDefinitions.h:673
GroundedAreaEnum
@ GroundedAreaEnum
Definition: EnumDefinitions.h:1089
Gauss
Definition: Gauss.h:8
Element::material
Material * material
Definition: Element.h:50
TriaEnum
@ TriaEnum
Definition: EnumDefinitions.h:1318
ElementsAndVerticesPartitioning
void ElementsAndVerticesPartitioning(IoModel *iomodel)
Definition: ElementsAndVerticesPartitioning.cpp:17
VxMeshEnum
@ VxMeshEnum
Definition: EnumDefinitions.h:847
Element::IcefrontMassFluxLevelset
virtual IssmDouble IcefrontMassFluxLevelset(bool scaled)
Definition: Element.h:272
FemModel::GetMesh
void GetMesh(Vertices *femmodel_vertices, Elements *femmodel_elements, IssmDouble **px, IssmDouble **py, int **pelementslist)
Definition: FemModel.cpp:3731
Nodes::NumberOfNodesLocal
int NumberOfNodesLocal(void)
Definition: Nodes.cpp:359
Element::GetVerticesLidList
void GetVerticesLidList(int *lidlist)
Definition: Element.cpp:1426
Analysis::UpdateConstraints
virtual void UpdateConstraints(FemModel *femmodel)=0
Analysis
Definition: Analysis.h:30
TransientInput2::AddTriaTimeInput
void AddTriaTimeInput(IssmDouble time, int numindices, int *indices, IssmDouble *values_in, int interp_in)
Definition: TransientInput2.cpp:138
TotalFloatingBmbEnum
@ TotalFloatingBmbEnum
Definition: EnumDefinitions.h:1307
FemModelEnum
@ FemModelEnum
Definition: EnumDefinitions.h:1064
Vector::SetValue
void SetValue(int dof, doubletype value, InsMode mode)
Definition: Vector.h:163
MeshXEnum
@ MeshXEnum
Definition: EnumDefinitions.h:1184
ThicknessAcrossGradientx
void ThicknessAcrossGradientx(IssmDouble *pJ, Elements *elements, Nodes *nodes, Vertices *vertices, Loads *loads, Materials *materials, Parameters *parameters)
Definition: ThicknessAcrossGradientx.cpp:11
ISSM_MPI_Gather
int ISSM_MPI_Gather(void *sendbuf, int sendcnt, ISSM_MPI_Datatype sendtype, void *recvbuf, int recvcnt, ISSM_MPI_Datatype recvtype, int root, ISSM_MPI_Comm comm)
Definition: issmmpi.cpp:242
Vertices::common_send_ids
int ** common_send_ids
Definition: Vertices.h:25
Vertex::Sid
int Sid(void)
Definition: Vertex.cpp:168
MaxVyEnum
@ MaxVyEnum
Definition: EnumDefinitions.h:1179
FlowequationIsHOEnum
@ FlowequationIsHOEnum
Definition: EnumDefinitions.h:139
Element::GetInputLocalMinMaxOnNodes
void GetInputLocalMinMaxOnNodes(IssmDouble *min, IssmDouble *max, IssmDouble *ug)
Definition: Element.cpp:1152
MinVelEnum
@ MinVelEnum
Definition: EnumDefinitions.h:1186
FemModel::WriteErrorEstimatorsInResults
void WriteErrorEstimatorsInResults(void)
Definition: FemModel.cpp:3642
HydrologyDCInefficientAnalysis::HydrologyIDSGetMask
void HydrologyIDSGetMask(Vector< IssmDouble > *vec_mask, Element *element)
Definition: HydrologyDCInefficientAnalysis.cpp:774
RheologyBbarAbsGradientEnum
@ RheologyBbarAbsGradientEnum
Definition: EnumDefinitions.h:674
Profiler::copy
Object * copy()
Definition: Profiler.cpp:31
SurfaceAverageVelMisfitx
void SurfaceAverageVelMisfitx(IssmDouble *pJ, FemModel *femmodel)
Definition: SurfaceAverageVelMisfitx.cpp:12
GenericParam
Definition: GenericParam.h:26
Analysis::CreateNodes
virtual void CreateNodes(Nodes *nodes, IoModel *iomodel, bool isamr=false)=0
Node::Activate
void Activate(void)
Definition: Node.cpp:632
FemModel::FemModel
FemModel(int argc, char **argv, ISSM_MPI_Comm comm_init, bool trace=false)
Definition: FemModel.cpp:56
ProfilingCurrentMemEnum
@ ProfilingCurrentMemEnum
Definition: EnumDefinitions.h:1235
ThicknessAcrossGradientEnum
@ ThicknessAcrossGradientEnum
Definition: EnumDefinitions.h:838
FlowequationIsL1L2Enum
@ FlowequationIsL1L2Enum
Definition: EnumDefinitions.h:140
ElementHook::numanalyses
int numanalyses
Definition: ElementHook.h:14
Element::ComputeDeviatoricStressTensor
virtual void ComputeDeviatoricStressTensor(void)=0
FemModel::GroundedAreax
void GroundedAreax(IssmDouble *pV, bool scaled)
Definition: FemModel.cpp:1530
DataSet::Marshall
void Marshall(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
Definition: DataSet.cpp:93
Generated on Thu Jul 2 2020 08:09:27 for Ice Sheet System Model by   doxygen 1.8.19