Index: /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp	(revision 17966)
+++ /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp	(revision 17967)
@@ -20,11 +20,9 @@
 
 /*Constructors/destructor/copy*/
-/*FUNCTION Penta::~Penta(){{{*/
-Penta::~Penta(){
+Penta::~Penta(){/*{{{*/
 	this->parameters=NULL;
 }
 /*}}}*/
-/*FUNCTION Penta::Penta(int id, int index, IoModel* iomodel,int nummodels) {{{*/
-Penta::Penta(int penta_id, int penta_sid, int index, IoModel* iomodel,int nummodels)
+Penta::Penta(int penta_id, int penta_sid, int index, IoModel* iomodel,int nummodels)/*{{{*/
 	:PentaRef(nummodels)
 	,ElementHook(nummodels,index+1,NUMVERTICES,iomodel){
@@ -61,6 +59,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::copy {{{*/
-Object* Penta::copy() {
+Object* Penta::copy() {/*{{{*/
 
 	int i;
@@ -108,6 +105,5 @@
 
 /*Other*/
-/*FUNCTION Penta::AddInput{{{*/
-void  Penta::AddInput(int input_enum,IssmDouble* values, int interpolation_enum){
+void       Penta::AddInput(int input_enum,IssmDouble* values, int interpolation_enum){/*{{{*/
 
 	_assert_(this->inputs);
@@ -115,6 +111,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::AddBasalInput{{{*/
-void  Penta::AddBasalInput(int input_enum,IssmDouble* values, int interpolation_enum){
+void       Penta::AddBasalInput(int input_enum,IssmDouble* values, int interpolation_enum){/*{{{*/
 
 	_assert_(this->inputs);
@@ -141,6 +136,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ComputeBasalStress {{{*/
-void  Penta::ComputeBasalStress(Vector<IssmDouble>* sigma_b){
+void       Penta::ComputeBasalStress(Vector<IssmDouble>* sigma_b){/*{{{*/
 
 	int         i,j;
@@ -229,6 +223,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ComputeStrainRate {{{*/
-void  Penta::ComputeStrainRate(){
+void       Penta::ComputeStrainRate(){/*{{{*/
 
 	IssmDouble      xyz_list[NUMVERTICES][3];
@@ -278,6 +271,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ComputeStressTensor {{{*/
-void  Penta::ComputeStressTensor(){
+void       Penta::ComputeStressTensor(){/*{{{*/
 
 	IssmDouble      xyz_list[NUMVERTICES][3];
@@ -332,6 +324,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ComputeDeviatoricStressTensor {{{*/
-void  Penta::ComputeDeviatoricStressTensor(){
+void       Penta::ComputeDeviatoricStressTensor(){/*{{{*/
 
 	IssmDouble      xyz_list[NUMVERTICES][3];
@@ -384,6 +375,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::Configure {{{*/
-void  Penta::Configure(Elements* elementsin, Loads* loadsin, Nodes* nodesin,Vertices* verticesin, Materials* materialsin, Parameters* parametersin){
+void       Penta::Configure(Elements* elementsin, Loads* loadsin, Nodes* nodesin,Vertices* verticesin, Materials* materialsin, Parameters* parametersin){/*{{{*/
 
 	int analysis_counter;
@@ -418,6 +408,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::Delta18oParameterization{{{*/
-void  Penta::Delta18oParameterization(void){
+void       Penta::Delta18oParameterization(void){/*{{{*/
 
 	/*Are we on the base? If not, return*/
@@ -493,11 +482,9 @@
 }
 /*}}}*/
-/*FUNCTION Penta::FiniteElement{{{*/
-int Penta::FiniteElement(void){
+int        Penta::FiniteElement(void){/*{{{*/
 	return this->element_type;
 }
 /*}}}*/
-/*FUNCTION Penta::FSContactMigration{{{*/
-void Penta::FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating){
+void       Penta::FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating){/*{{{*/
 
 	if(!IsOnBase()) return;
@@ -580,6 +567,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ObjectEnum{{{*/
-int Penta::ObjectEnum(void){
+int        Penta::ObjectEnum(void){/*{{{*/
 
 	return PentaEnum;
@@ -587,6 +573,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetAreaCoordinates{{{*/
-void Penta::GetAreaCoordinates(IssmDouble* area_coordinates,IssmDouble* xyz_zero,IssmDouble* xyz_list,int numpoints){
+void       Penta::GetAreaCoordinates(IssmDouble* area_coordinates,IssmDouble* xyz_zero,IssmDouble* xyz_list,int numpoints){/*{{{*/
 	/*Computeportion of the element that is grounded*/ 
 
@@ -623,6 +608,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetUpperPenta{{{*/
-Penta* Penta::GetUpperPenta(void){
+Penta*     Penta::GetUpperPenta(void){/*{{{*/
 
 	Penta* upper_penta=NULL;
@@ -633,6 +617,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetLowerPenta{{{*/
-Penta* Penta::GetLowerPenta(void){
+Penta*     Penta::GetLowerPenta(void){/*{{{*/
 
 	Penta* lower_penta=NULL;
@@ -643,6 +626,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetSurfacePenta{{{*/
-Penta* Penta::GetSurfacePenta(void){
+Penta*     Penta::GetSurfacePenta(void){/*{{{*/
 
 	/*Output*/
@@ -664,6 +646,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetBasalPenta{{{*/
-Penta* Penta::GetBasalPenta(void){
+Penta*     Penta::GetBasalPenta(void){/*{{{*/
 
 	/*Output*/
@@ -685,6 +666,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetUpperElement{{{*/
-Element* Penta::GetUpperElement(void){
+Element*   Penta::GetUpperElement(void){/*{{{*/
 
 	/*Output*/
@@ -693,6 +673,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetBasalElement{{{*/
-Element* Penta::GetBasalElement(void){
+Element*   Penta::GetBasalElement(void){/*{{{*/
 
 	/*Output*/
@@ -701,6 +680,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetGroundedPart{{{*/
-void Penta::GetGroundedPart(int* point1,IssmDouble* fraction1,IssmDouble* fraction2, bool* mainlyfloating){
+void       Penta::GetGroundedPart(int* point1,IssmDouble* fraction1,IssmDouble* fraction2, bool* mainlyfloating){/*{{{*/
 	/*Computeportion of the element that is grounded*/ 
 
@@ -755,6 +733,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetGroundedPortion{{{*/
-IssmDouble Penta::GetGroundedPortion(IssmDouble* xyz_list){
+IssmDouble Penta::GetGroundedPortion(IssmDouble* xyz_list){/*{{{*/
 	/*Computeportion of the element that is grounded*/ 
 
@@ -857,6 +834,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetElementType {{{*/
-int Penta::GetElementType(){
+int        Penta::GetElementType(){/*{{{*/
 
 	/*return PentaRef field*/
@@ -864,6 +840,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ElementSizes{{{*/
-void Penta::ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz){
+void       Penta::ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz){/*{{{*/
 
 	IssmDouble xyz_list[NUMVERTICES][3];
@@ -891,6 +866,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetNodeIndex {{{*/
-int Penta::GetNodeIndex(Node* node){
+int        Penta::GetNodeIndex(Node* node){/*{{{*/
 
 	_assert_(nodes);
@@ -904,16 +878,13 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetNumberOfNodes;{{{*/
-int Penta::GetNumberOfNodes(void){
+int        Penta::GetNumberOfNodes(void){/*{{{*/
 	return this->NumberofNodes();
 }
 /*}}}*/
-/*FUNCTION Penta::GetNumberOfVertices;{{{*/
-int Penta::GetNumberOfVertices(void){
+int        Penta::GetNumberOfVertices(void){/*{{{*/
 	return NUMVERTICES; 
 }
 /*}}}*/
-/*FUNCTION Penta::GetNode(int node_number) {{{*/
-Node* Penta::GetNode(int node_number){
+Node* Penta::GetNode(int node_number){/*{{{*/
 	_assert_(node_number>=0); 
 	_assert_(node_number<this->NumberofNodes()); 
@@ -921,6 +892,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetInputValue(IssmDouble* pvalue,Node* node,int enumtype) {{{*/
-void Penta::GetInputValue(IssmDouble* pvalue,Node* node,int enumtype){
+void       Penta::GetInputValue(IssmDouble* pvalue,Node* node,int enumtype){/*{{{*/
 
 	Input* input=inputs->GetInput(enumtype);
@@ -934,6 +904,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetVerticesCoordinatesBase(IssmDouble** pxyz_list){{{*/
-void Penta::GetVerticesCoordinatesBase(IssmDouble** pxyz_list){
+void       Penta::GetVerticesCoordinatesBase(IssmDouble** pxyz_list){/*{{{*/
 
 	IssmDouble* xyz_list = xNew<IssmDouble>(NUMVERTICES2D*3);
@@ -944,6 +913,5 @@
 
 }/*}}}*/
-/*FUNCTION Penta::GetVerticesCoordinatesTop(IssmDouble** pxyz_list){{{*/
-void Penta::GetVerticesCoordinatesTop(IssmDouble** pxyz_list){
+void       Penta::GetVerticesCoordinatesTop(IssmDouble** pxyz_list){/*{{{*/
 
 	IssmDouble* xyz_list = xNew<IssmDouble>(NUMVERTICES2D*3);
@@ -954,6 +922,5 @@
 
 }/*}}}*/
-/*FUNCTION Penta::NormalSection{{{*/
-void Penta::NormalSection(IssmDouble* normal,IssmDouble* xyz_list){
+void       Penta::NormalSection(IssmDouble* normal,IssmDouble* xyz_list){/*{{{*/
 
 	/*Build unit outward pointing vector*/
@@ -975,6 +942,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::StabilizationParameter {{{*/
-IssmDouble Penta::StabilizationParameter(IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble diameter, IssmDouble kappa){
+IssmDouble Penta::StabilizationParameter(IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble diameter, IssmDouble kappa){/*{{{*/
 	/*Compute stabilization parameter*/
 	/*kappa=thermalconductivity/(rho_ice*hearcapacity) for thermal model*/
@@ -993,6 +959,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ZeroLevelsetCoordinates{{{*/
-void Penta::ZeroLevelsetCoordinates(IssmDouble** pxyz_zero,IssmDouble* xyz_list,int levelsetenum){
+void       Penta::ZeroLevelsetCoordinates(IssmDouble** pxyz_zero,IssmDouble* xyz_list,int levelsetenum){/*{{{*/
 	/*Compute portion of the element that is grounded*/ 
 
@@ -1149,6 +1114,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::InputDepthAverageAtBase{{{*/
-void  Penta::InputDepthAverageAtBase(int enum_type,int average_enum_type){
+void       Penta::InputDepthAverageAtBase(int enum_type,int average_enum_type){/*{{{*/
 
 	int  step,i;
@@ -1251,6 +1215,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::InputExtrude {{{*/
-void  Penta::InputExtrude(int enum_type){
+void       Penta::InputExtrude(int enum_type){/*{{{*/
 
 	int     i,num_inputs;
@@ -1295,6 +1258,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::InputScale{{{*/
-void  Penta::InputScale(int enum_type,IssmDouble scale_factor){
+void       Penta::InputScale(int enum_type,IssmDouble scale_factor){/*{{{*/
 
 	Input* input=NULL;
@@ -1308,6 +1270,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::InputUpdateFromIoModel {{{*/
-void Penta::InputUpdateFromIoModel(int index,IoModel* iomodel){ 
+void       Penta::InputUpdateFromIoModel(int index,IoModel* iomodel){ /*{{{*/
 
 	/*Intermediaries*/
@@ -1405,6 +1366,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::InputUpdateFromSolutionOneDof{{{*/
-void  Penta::InputUpdateFromSolutionOneDof(IssmDouble* solution,int enum_type){
+void       Penta::InputUpdateFromSolutionOneDof(IssmDouble* solution,int enum_type){/*{{{*/
 
 	/*Intermediary*/
@@ -1432,6 +1392,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::InputUpdateFromSolutionOneDofCollpased{{{*/
-void  Penta::InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solution,int enum_type){
+void       Penta::InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solution,int enum_type){/*{{{*/
 
 	const int  numdof   = NDOF1*NUMVERTICES;
@@ -1472,6 +1431,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::InputUpdateFromVector(IssmDouble* vector, int name, int type);{{{*/
-void  Penta::InputUpdateFromVector(IssmDouble* vector, int name, int type){
+void       Penta::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
 
 	const int   numdof         = NDOF1 *NUMVERTICES;
@@ -1532,6 +1490,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::IsOnBase{{{*/
-bool Penta::IsOnBase(void){
+bool       Penta::IsOnBase(void){/*{{{*/
 
 	IssmDouble values[NUMVERTICES];
@@ -1551,6 +1508,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::IsOnSurface{{{*/
-bool Penta::IsOnSurface(void){
+bool       Penta::IsOnSurface(void){/*{{{*/
 
 	IssmDouble values[NUMVERTICES];
@@ -1570,6 +1526,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::IsNodeOnShelfFromFlags {{{*/
-bool   Penta::IsNodeOnShelfFromFlags(IssmDouble* flags){
+bool   Penta::IsNodeOnShelfFromFlags(IssmDouble* flags){/*{{{*/
 
 	int  i;
@@ -1585,6 +1540,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::JacobianDeterminant{{{*/
-void Penta::JacobianDeterminant(IssmDouble* pJdet,IssmDouble* xyz_list,Gauss* gauss){
+void       Penta::JacobianDeterminant(IssmDouble* pJdet,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1593,6 +1547,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::JacobianDeterminantBase{{{*/
-void Penta::JacobianDeterminantBase(IssmDouble* pJdet,IssmDouble* xyz_list_base,Gauss* gauss){
+void       Penta::JacobianDeterminantBase(IssmDouble* pJdet,IssmDouble* xyz_list_base,Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1601,6 +1554,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::JacobianDeterminantLine{{{*/
-void Penta::JacobianDeterminantLine(IssmDouble* pJdet,IssmDouble* xyz_list_line,Gauss* gauss){
+void       Penta::JacobianDeterminantLine(IssmDouble* pJdet,IssmDouble* xyz_list_line,Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1609,6 +1561,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::JacobianDeterminantTop{{{*/
-void Penta::JacobianDeterminantTop(IssmDouble* pJdet,IssmDouble* xyz_list_top,Gauss* gauss){
+void       Penta::JacobianDeterminantTop(IssmDouble* pJdet,IssmDouble* xyz_list_top,Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1617,6 +1568,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::JacobianDeterminantSurface{{{*/
-void Penta::JacobianDeterminantSurface(IssmDouble* pJdet,IssmDouble* xyz_list_quad,Gauss* gauss){
+void       Penta::JacobianDeterminantSurface(IssmDouble* pJdet,IssmDouble* xyz_list_quad,Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1625,6 +1575,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MinEdgeLength{{{*/
-IssmDouble Penta::MinEdgeLength(IssmDouble* xyz_list){
+IssmDouble Penta::MinEdgeLength(IssmDouble* xyz_list){/*{{{*/
 	/*Return the minimum lenght of the nine egdes of the penta*/
 
@@ -1647,6 +1596,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NodalValue {{{*/
-int    Penta::NodalValue(IssmDouble* pvalue, int index, int natureofdataenum){
+int    Penta::NodalValue(IssmDouble* pvalue, int index, int natureofdataenum){/*{{{*/
 
 	int i;
@@ -1679,16 +1627,13 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NewGauss(){{{*/
-Gauss* Penta::NewGauss(void){
+Gauss* Penta::NewGauss(void){/*{{{*/
 	return new GaussPenta();
 }
 /*}}}*/
-/*FUNCTION Penta::NewGauss(int order){{{*/
-Gauss* Penta::NewGauss(int order){
+Gauss* Penta::NewGauss(int order){/*{{{*/
 	return new GaussPenta(order,order);
 }
 /*}}}*/
-/*FUNCTION Penta::NewGauss(IssmDouble* xyz_list, IssmDouble* xyz_list_front,int order_horiz,int order_vert){{{*/
-Gauss* Penta::NewGauss(IssmDouble* xyz_list, IssmDouble* xyz_list_front,int order_horiz,int order_vert){
+Gauss* Penta::NewGauss(IssmDouble* xyz_list, IssmDouble* xyz_list_front,int order_horiz,int order_vert){/*{{{*/
 
 	IssmDouble  area_coordinates[4][3];
@@ -1699,21 +1644,17 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NewGaussBase(int order){{{*/
-Gauss* Penta::NewGaussBase(int order){
+Gauss* Penta::NewGaussBase(int order){/*{{{*/
 	return new GaussPenta(0,1,2,order);
 }
 /*}}}*/
-/*FUNCTION Penta::NewGaussLine(int vertex1,int vertex2,int order){{{*/
-Gauss* Penta::NewGaussLine(int vertex1,int vertex2,int order){
+Gauss* Penta::NewGaussLine(int vertex1,int vertex2,int order){/*{{{*/
 	return new GaussPenta(vertex1,vertex2,order);
 }
 /*}}}*/
-/*FUNCTION Penta::NewGaussTop(int order){{{*/
-Gauss* Penta::NewGaussTop(int order){
+Gauss* Penta::NewGaussTop(int order){/*{{{*/
 	return new GaussPenta(3,4,5,order);
 }
 /*}}}*/
-/*FUNCTION Penta::NodalFunctions{{{*/
-void Penta::NodalFunctions(IssmDouble* basis, Gauss* gauss){
+void       Penta::NodalFunctions(IssmDouble* basis, Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1722,6 +1663,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NodalFunctionsP1{{{*/
-void Penta::NodalFunctionsP1(IssmDouble* basis, Gauss* gauss){
+void       Penta::NodalFunctionsP1(IssmDouble* basis, Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1730,6 +1670,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NodalFunctionsDerivatives{{{*/
-void Penta::NodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){
+void       Penta::NodalFunctionsDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1738,6 +1677,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NodalFunctionsP1Derivatives{{{*/
-void Penta::NodalFunctionsP1Derivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){
+void       Penta::NodalFunctionsP1Derivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1746,6 +1684,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NodalFunctionsMINIDerivatives{{{*/
-void Penta::NodalFunctionsMINIDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){
+void       Penta::NodalFunctionsMINIDerivatives(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1754,6 +1691,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NodalFunctionsDerivativesVelocity{{{*/
-void Penta::NodalFunctionsDerivativesVelocity(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){
+void       Penta::NodalFunctionsDerivativesVelocity(IssmDouble* dbasis,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1762,6 +1698,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NodalFunctionsVelocity{{{*/
-void Penta::NodalFunctionsVelocity(IssmDouble* basis, Gauss* gauss){
+void       Penta::NodalFunctionsVelocity(IssmDouble* basis, Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1770,6 +1705,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NodalFunctionsPressure{{{*/
-void Penta::NodalFunctionsPressure(IssmDouble* basis, Gauss* gauss){
+void       Penta::NodalFunctionsPressure(IssmDouble* basis, Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1778,6 +1712,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NodalFunctionsTensor{{{*/
-void Penta::NodalFunctionsTensor(IssmDouble* basis, Gauss* gauss){
+void       Penta::NodalFunctionsTensor(IssmDouble* basis, Gauss* gauss){/*{{{*/
 
 	_assert_(gauss->Enum()==GaussPentaEnum);
@@ -1786,6 +1719,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NormalBase {{{*/
-void Penta::NormalBase(IssmDouble* bed_normal,IssmDouble* xyz_list){
+void       Penta::NormalBase(IssmDouble* bed_normal,IssmDouble* xyz_list){/*{{{*/
 
 	IssmDouble v13[3],v23[3];
@@ -1809,6 +1741,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NormalTop {{{*/
-void Penta::NormalTop(IssmDouble* top_normal,IssmDouble* xyz_list){
+void       Penta::NormalTop(IssmDouble* top_normal,IssmDouble* xyz_list){/*{{{*/
 
 	int i;
@@ -1832,16 +1763,13 @@
 }
 /*}}}*/
-/*FUNCTION Penta::NumberofNodesPressure{{{*/
-int Penta::NumberofNodesPressure(void){
+int        Penta::NumberofNodesPressure(void){/*{{{*/
 	return PentaRef::NumberofNodes(this->PressureInterpolation());
 }
 /*}}}*/
-/*FUNCTION Penta::NumberofNodesVelocity{{{*/
-int Penta::NumberofNodesVelocity(void){
+int        Penta::NumberofNodesVelocity(void){/*{{{*/
 	return PentaRef::NumberofNodes(this->VelocityInterpolation());
 }
 /*}}}*/
-/*FUNCTION Penta::PositiveDegreeDay{{{*/
-void  Penta::PositiveDegreeDay(IssmDouble* pdds,IssmDouble* pds,IssmDouble signorm){
+void       Penta::PositiveDegreeDay(IssmDouble* pdds,IssmDouble* pds,IssmDouble signorm){/*{{{*/
 
    IssmDouble agd[NUMVERTICES];             // surface mass balance
@@ -1894,6 +1822,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ReduceMatrices{{{*/
-void Penta::ReduceMatrices(ElementMatrix* Ke,ElementVector* pe){
+void       Penta::ReduceMatrices(ElementMatrix* Ke,ElementVector* pe){/*{{{*/
 
 	int analysis_type;
@@ -1951,6 +1878,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ResetFSBasalBoundaryCondition{{{*/
-void  Penta::ResetFSBasalBoundaryCondition(void){
+void       Penta::ResetFSBasalBoundaryCondition(void){/*{{{*/
 
 	int          approximation;
@@ -2014,12 +1940,10 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SetClone {{{*/
-void  Penta::SetClone(int* minranks){
+void       Penta::SetClone(int* minranks){/*{{{*/
 
 	_error_("not implemented yet");
 }
 /*}}}*/
-/*FUNCTION Penta::SetCurrentConfiguration {{{*/
-void  Penta::SetCurrentConfiguration(Elements* elementsin, Loads* loadsin, Nodes* nodesin, Materials* materialsin, Parameters* parametersin){
+void       Penta::SetCurrentConfiguration(Elements* elementsin, Loads* loadsin, Nodes* nodesin, Materials* materialsin, Parameters* parametersin){/*{{{*/
 
 	/*go into parameters and get the analysis_counter: */
@@ -2036,11 +1960,9 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SetTemporaryElementType{{{*/
-void Penta::SetTemporaryElementType(int element_type_in){
+void       Penta::SetTemporaryElementType(int element_type_in){/*{{{*/
 	this->element_type=element_type_in;
 }
 /*}}}*/
-/*FUNCTION Penta::SpawnTria {{{*/
-Tria*  Penta::SpawnTria(int index1,int index2,int index3){
+Tria*      Penta::SpawnTria(int index1,int index2,int index3){/*{{{*/
 
 	int analysis_counter;
@@ -2069,6 +1991,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SpawnBasalElement{{{*/
-Element*  Penta::SpawnBasalElement(void){
+Element*   Penta::SpawnBasalElement(void){/*{{{*/
 
 	_assert_(this->IsOnBase());
@@ -2087,6 +2008,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SpawnTopElement{{{*/
-Element*  Penta::SpawnTopElement(void){
+Element*   Penta::SpawnTopElement(void){/*{{{*/
 
 	_assert_(this->IsOnSurface());
@@ -2097,6 +2017,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SmbGradients{{{*/
-void Penta::SmbGradients(void){
+void       Penta::SmbGradients(void){/*{{{*/
 
 	int i;
@@ -2143,6 +2062,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SurfaceArea {{{*/
-IssmDouble Penta::SurfaceArea(void){
+IssmDouble Penta::SurfaceArea(void){/*{{{*/
 
 	int    approximation;
@@ -2180,6 +2098,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::TimeAdapt{{{*/
-IssmDouble  Penta::TimeAdapt(void){
+IssmDouble Penta::TimeAdapt(void){/*{{{*/
 
 	int    i;
@@ -2224,6 +2141,5 @@
 	return dt;
 }/*}}}*/
-/*FUNCTION Penta::Update {{{*/
-void Penta::Update(int index,IoModel* iomodel,int analysis_counter,int analysis_type,int finiteelement_type){ 
+void       Penta::Update(int index,IoModel* iomodel,int analysis_counter,int analysis_type,int finiteelement_type){ /*{{{*/
 
 	/*Intermediaries*/
@@ -2531,6 +2447,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::UpdateConstraintsExtrudeFromBase{{{*/
-void  Penta::UpdateConstraintsExtrudeFromBase(void){
+void       Penta::UpdateConstraintsExtrudeFromBase(void){/*{{{*/
 
 	if(!IsOnBase()) return;
@@ -2556,6 +2471,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::UpdateConstraintsExtrudeFromTop{{{*/
-void  Penta::UpdateConstraintsExtrudeFromTop(void){
+void       Penta::UpdateConstraintsExtrudeFromTop(void){/*{{{*/
 
 	if(!IsOnSurface()) return;
@@ -2578,22 +2492,18 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ValueP1OnGauss{{{*/
-void Penta::ValueP1OnGauss(IssmDouble* pvalue,IssmDouble* values,Gauss* gauss){
+void       Penta::ValueP1OnGauss(IssmDouble* pvalue,IssmDouble* values,Gauss* gauss){/*{{{*/
 	PentaRef::GetInputValue(pvalue,values,gauss,P1Enum);
 }
 /*}}}*/
-/*FUNCTION Penta::ValueP1DerivativesOnGauss{{{*/
-void Penta::ValueP1DerivativesOnGauss(IssmDouble* dvalue,IssmDouble* values,IssmDouble* xyz_list,Gauss* gauss){
+void       Penta::ValueP1DerivativesOnGauss(IssmDouble* dvalue,IssmDouble* values,IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
 	PentaRef::GetInputDerivativeValue(dvalue,values,xyz_list,gauss);
 }
 /*}}}*/
-/*FUNCTION Penta::VertexConnectivity{{{*/
-int Penta::VertexConnectivity(int vertexindex){
+int        Penta::VertexConnectivity(int vertexindex){/*{{{*/
 	_assert_(this->vertices);
 	return this->vertices[vertexindex]->Connectivity();
 }
 /*}}}*/
-/*FUNCTION Penta::VerticalSegmentIndices{{{*/
-void Penta::VerticalSegmentIndices(int** pindices,int* pnumseg){
+void       Penta::VerticalSegmentIndices(int** pindices,int* pnumseg){/*{{{*/
 
 	/*output*/
@@ -2608,6 +2518,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ViscousHeating{{{*/
-void Penta::ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){
+void       Penta::ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
 
 	/*Intermediaries*/
@@ -2625,16 +2534,13 @@
 }
 /*}}}*/
-/*FUNCTION Penta::VelocityInterpolation{{{*/
-int Penta::VelocityInterpolation(void){
+int        Penta::VelocityInterpolation(void){/*{{{*/
 	return PentaRef::VelocityInterpolation();
 }
 /*}}}*/
-/*FUNCTION Penta::PressureInterpolation{{{*/
-int Penta::PressureInterpolation(void){
+int        Penta::PressureInterpolation(void){/*{{{*/
 	return PentaRef::PressureInterpolation();
 }
 /*}}}*/
-/*FUNCTION Penta::IsZeroLevelset{{{*/
-bool Penta::IsZeroLevelset(int levelset_enum){
+bool       Penta::IsZeroLevelset(int levelset_enum){/*{{{*/
 
 	bool        iszerols;
@@ -2654,5 +2560,5 @@
 }
 /*}}}*/
-bool  Penta::IsIcefront(void){/*{{{*/
+bool       Penta::IsIcefront(void){/*{{{*/
 
 	bool isicefront;
@@ -2673,11 +2579,9 @@
 	return isicefront;
 }/*}}}*/
-/*FUNCTION Penta::AverageOntoPartition {{{*/
-void  Penta::AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part){
+void       Penta::AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part){/*{{{*/
 	_error_("Not supported yet!");
 }
 /*}}}*/
-/*FUNCTION Penta::IceVolume {{{*/
-IssmDouble Penta::IceVolume(void){
+IssmDouble Penta::IceVolume(void){/*{{{*/
 
 	/*The volume of a troncated prism is base * 1/3 sum(length of edges)*/
@@ -2701,6 +2605,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::IceVolumeAboveFloatation {{{*/
-IssmDouble Penta::IceVolumeAboveFloatation(void){
+IssmDouble Penta::IceVolumeAboveFloatation(void){/*{{{*/
 
 	/*Volume above floatation: H + rho_water/rho_ice*bathymetry for nodes on the bed*/
@@ -2732,6 +2635,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MinVel{{{*/
-void  Penta::MinVel(IssmDouble* pminvel){
+void       Penta::MinVel(IssmDouble* pminvel){/*{{{*/
 
 	/*Get minimum:*/
@@ -2742,6 +2644,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MinVx{{{*/
-void  Penta::MinVx(IssmDouble* pminvx){
+void       Penta::MinVx(IssmDouble* pminvx){/*{{{*/
 
 	/*Get minimum:*/
@@ -2752,6 +2653,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MinVy{{{*/
-void  Penta::MinVy(IssmDouble* pminvy){
+void       Penta::MinVy(IssmDouble* pminvy){/*{{{*/
 
 	/*Get minimum:*/
@@ -2762,6 +2662,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MinVz{{{*/
-void  Penta::MinVz(IssmDouble* pminvz){
+void       Penta::MinVz(IssmDouble* pminvz){/*{{{*/
 
 	/*Get minimum:*/
@@ -2772,6 +2671,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MassFlux {{{*/
-IssmDouble Penta::MassFlux( IssmDouble* segment){
+IssmDouble Penta::MassFlux( IssmDouble* segment){/*{{{*/
 
 	IssmDouble mass_flux=0;
@@ -2796,6 +2694,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MassFlux {{{*/
-IssmDouble Penta::MassFlux( IssmDouble x1, IssmDouble y1, IssmDouble x2, IssmDouble y2,int segment_id){
+IssmDouble Penta::MassFlux( IssmDouble x1, IssmDouble y1, IssmDouble x2, IssmDouble y2,int segment_id){/*{{{*/
 
 	IssmDouble mass_flux=0;
@@ -2820,6 +2717,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MaxAbsVx{{{*/
-void  Penta::MaxAbsVx(IssmDouble* pmaxabsvx){
+void       Penta::MaxAbsVx(IssmDouble* pmaxabsvx){/*{{{*/
 
 	/*Get maximum:*/
@@ -2830,6 +2726,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MaxAbsVy{{{*/
-void  Penta::MaxAbsVy(IssmDouble* pmaxabsvy){
+void       Penta::MaxAbsVy(IssmDouble* pmaxabsvy){/*{{{*/
 
 	/*Get maximum:*/
@@ -2840,6 +2735,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MaxAbsVz{{{*/
-void  Penta::MaxAbsVz(IssmDouble* pmaxabsvz){
+void       Penta::MaxAbsVz(IssmDouble* pmaxabsvz){/*{{{*/
 
 	/*Get maximum:*/
@@ -2850,6 +2744,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MaxVel{{{*/
-void  Penta::MaxVel(IssmDouble* pmaxvel){
+void       Penta::MaxVel(IssmDouble* pmaxvel){/*{{{*/
 
 	/*Get maximum:*/
@@ -2861,6 +2754,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MaxVx{{{*/
-void  Penta::MaxVx(IssmDouble* pmaxvx){
+void       Penta::MaxVx(IssmDouble* pmaxvx){/*{{{*/
 
 	/*Get maximum:*/
@@ -2871,6 +2763,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MaxVy{{{*/
-void  Penta::MaxVy(IssmDouble* pmaxvy){
+void       Penta::MaxVy(IssmDouble* pmaxvy){/*{{{*/
 
 	/*Get maximum:*/
@@ -2881,6 +2772,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MaxVz{{{*/
-void  Penta::MaxVz(IssmDouble* pmaxvz){
+void       Penta::MaxVz(IssmDouble* pmaxvz){/*{{{*/
 
 	/*Get maximum:*/
@@ -2891,6 +2781,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ElementResponse{{{*/
-void Penta::ElementResponse(IssmDouble* presponse,int response_enum){
+void       Penta::ElementResponse(IssmDouble* presponse,int response_enum){/*{{{*/
 
 	switch(response_enum){
@@ -2921,6 +2810,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::TotalSmb {{{*/
-IssmDouble Penta::TotalSmb(void){
+IssmDouble Penta::TotalSmb(void){/*{{{*/
 
 	/*The smb[Gt yr-1] of one element is area[m2] * smb [ m ice yr^-1] * rho_ice [kg m-3] / 1e+10^12 */
@@ -2953,6 +2841,5 @@
 
 #ifdef _HAVE_GIA_
-/*FUNCTION Penta::GiaDeflection {{{*/
-void Penta::GiaDeflection(Vector<IssmDouble>* wg,Vector<IssmDouble>* dwgdt,IssmDouble* x,IssmDouble* y){
+void       Penta::GiaDeflection(Vector<IssmDouble>* wg,Vector<IssmDouble>* dwgdt,IssmDouble* x,IssmDouble* y){/*{{{*/
 	_error_("GIA deflection not implemented yet!");
 }
@@ -2960,6 +2847,5 @@
 #endif
 
-/*FUNCTION Penta::ControlInputGetGradient{{{*/
-void Penta::ControlInputGetGradient(Vector<IssmDouble>* gradient,int enum_type,int control_index){
+void       Penta::ControlInputGetGradient(Vector<IssmDouble>* gradient,int enum_type,int control_index){/*{{{*/
 
 	int vertexpidlist[NUMVERTICES];
@@ -2984,6 +2870,5 @@
 
 }/*}}}*/
-/*FUNCTION Penta::ControlInputScaleGradient{{{*/
-void Penta::ControlInputScaleGradient(int enum_type,IssmDouble scale){
+void       Penta::ControlInputScaleGradient(int enum_type,IssmDouble scale){/*{{{*/
 
 	Input* input=NULL;
@@ -3003,6 +2888,5 @@
 	((ControlInput*)input)->ScaleGradient(scale);
 }/*}}}*/
-/*FUNCTION Penta::ControlInputSetGradient{{{*/
-void Penta::ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index){
+void       Penta::ControlInputSetGradient(IssmDouble* gradient,int enum_type,int control_index){/*{{{*/
 
 	int    vertexpidlist[NUMVERTICES];
@@ -3029,6 +2913,5 @@
 
 }/*}}}*/
-/*FUNCTION Penta::ControlToVectors{{{*/
-void Penta::ControlToVectors(Vector<IssmPDouble>* vector_control, Vector<IssmPDouble>* vector_gradient,int control_enum){
+void       Penta::ControlToVectors(Vector<IssmPDouble>* vector_control, Vector<IssmPDouble>* vector_gradient,int control_enum){/*{{{*/
 
 	Input* input=NULL;
@@ -3071,6 +2954,5 @@
 
 }/*}}}*/
-/*FUNCTION Penta::GradientIndexing{{{*/
-void Penta::GradientIndexing(int* indexing,int control_index){
+void       Penta::GradientIndexing(int* indexing,int control_index){/*{{{*/
 
 	/*Get some parameters*/
@@ -3085,6 +2967,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::Gradj {{{*/
-void  Penta::Gradj(Vector<IssmDouble>* gradient,int control_type,int control_index){
+void       Penta::Gradj(Vector<IssmDouble>* gradient,int control_type,int control_index){/*{{{*/
 	/*dJ/dalpha = ∂L/∂alpha = ∂J/∂alpha + ∂/∂alpha(KU-F)*/
 
@@ -3178,6 +3059,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GradjDragSSA {{{*/
-void  Penta::GradjDragSSA(Vector<IssmDouble>* gradient,int control_index){
+void       Penta::GradjDragSSA(Vector<IssmDouble>* gradient,int control_index){/*{{{*/
 
 	/*Gradient is 0 if on shelf or not on bed*/
@@ -3190,6 +3070,5 @@
 
 } /*}}}*/
-/*FUNCTION Penta::GradjDragHO {{{*/
-void  Penta::GradjDragHO(Vector<IssmDouble>* gradient,int control_index){
+void       Penta::GradjDragHO(Vector<IssmDouble>* gradient,int control_index){/*{{{*/
 
 	int        i,j;
@@ -3261,6 +3140,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GradjDragFS {{{*/
-void  Penta::GradjDragFS(Vector<IssmDouble>* gradient,int control_index){
+void       Penta::GradjDragFS(Vector<IssmDouble>* gradient,int control_index){/*{{{*/
 
 	int        i,j;
@@ -3353,6 +3231,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GradjBbarSSA {{{*/
-void  Penta::GradjBbarSSA(Vector<IssmDouble>* gradient,int control_index){
+void       Penta::GradjBbarSSA(Vector<IssmDouble>* gradient,int control_index){/*{{{*/
 
 	/*This element should be collapsed into a tria element at its base*/
@@ -3373,6 +3250,5 @@
 
 } /*}}}*/
-/*FUNCTION Penta::GradjBbarHO {{{*/
-void  Penta::GradjBbarHO(Vector<IssmDouble>* gradient,int control_index){
+void       Penta::GradjBbarHO(Vector<IssmDouble>* gradient,int control_index){/*{{{*/
 
 	/*Gradient is computed on bed only (Bbar)*/
@@ -3392,6 +3268,5 @@
 	this->inputs->DeleteInput(DamageDbarEnum);
 } /*}}}*/
-/*FUNCTION Penta::GradjBbarFS {{{*/
-void  Penta::GradjBbarFS(Vector<IssmDouble>* gradient,int control_index){
+void       Penta::GradjBbarFS(Vector<IssmDouble>* gradient,int control_index){/*{{{*/
 
 	/*Gradient is computed on bed only (Bbar)*/
@@ -3411,6 +3286,5 @@
 	this->inputs->DeleteInput(DamageDbarEnum);
 } /*}}}*/
-/*FUNCTION Penta::InputControlUpdate{{{*/
-void  Penta::InputControlUpdate(IssmDouble scalar,bool save_parameter){
+void       Penta::InputControlUpdate(IssmDouble scalar,bool save_parameter){/*{{{*/
 
 	/*Intermediary*/
@@ -3455,6 +3329,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SurfaceAverageVelMisfit {{{*/
-IssmDouble Penta::SurfaceAverageVelMisfit(void){
+IssmDouble Penta::SurfaceAverageVelMisfit(void){/*{{{*/
 
 	int    approximation;
@@ -3492,6 +3365,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SurfaceAbsVelMisfit {{{*/
-IssmDouble Penta::SurfaceAbsVelMisfit(void){
+IssmDouble Penta::SurfaceAbsVelMisfit(void){/*{{{*/
 
 	int    approximation;
@@ -3529,6 +3401,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SurfaceLogVelMisfit {{{*/
-IssmDouble Penta::SurfaceLogVelMisfit(void){
+IssmDouble Penta::SurfaceLogVelMisfit(void){/*{{{*/
 
 	int    approximation;
@@ -3566,6 +3437,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SurfaceLogVxVyMisfit {{{*/
-IssmDouble Penta::SurfaceLogVxVyMisfit(void){
+IssmDouble Penta::SurfaceLogVxVyMisfit(void){/*{{{*/
 
 	IssmDouble J;
@@ -3605,6 +3475,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SurfaceRelVelMisfit {{{*/
-IssmDouble Penta::SurfaceRelVelMisfit(void){
+IssmDouble Penta::SurfaceRelVelMisfit(void){/*{{{*/
 
 	int    approximation;
@@ -3642,12 +3511,10 @@
 }
 /*}}}*/
-/*FUNCTION Penta::ThicknessAbsGradient{{{*/
-IssmDouble Penta::ThicknessAbsGradient(void){
+IssmDouble Penta::ThicknessAbsGradient(void){/*{{{*/
 
 	_error_("Not implemented yet");
 }
 /*}}}*/
-/*FUNCTION Penta::ThicknessAbsMisfit {{{*/
-IssmDouble Penta::ThicknessAbsMisfit(void){
+IssmDouble Penta::ThicknessAbsMisfit(void){/*{{{*/
 
 	int    approximation;
@@ -3668,6 +3535,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::DragCoefficientAbsGradient{{{*/
-IssmDouble Penta::DragCoefficientAbsGradient(void){
+IssmDouble Penta::DragCoefficientAbsGradient(void){/*{{{*/
 
 	IssmDouble J;
@@ -3683,6 +3549,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::RheologyBbarAbsGradient{{{*/
-IssmDouble Penta::RheologyBbarAbsGradient(void){
+IssmDouble Penta::RheologyBbarAbsGradient(void){/*{{{*/
 
 	IssmDouble J;
@@ -3698,6 +3563,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::GetVectorFromControlInputs{{{*/
-void  Penta::GetVectorFromControlInputs(Vector<IssmDouble>* vector,int control_enum,int control_index,const char* data){
+void       Penta::GetVectorFromControlInputs(Vector<IssmDouble>* vector,int control_enum,int control_index,const char* data){/*{{{*/
 
 	int vertexpidlist[NUMVERTICES];
@@ -3721,6 +3585,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SetControlInputsFromVector{{{*/
-void  Penta::SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index){
+void       Penta::SetControlInputsFromVector(IssmDouble* vector,int control_enum,int control_index){/*{{{*/
 
 	IssmDouble  values[NUMVERTICES];
@@ -3751,6 +3614,5 @@
 
 #ifdef _HAVE_DAKOTA_
-/*FUNCTION Penta::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type);{{{*/
-void  Penta::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){
+void       Penta::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/
 
 	int i,j;
@@ -3852,6 +3714,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols, int name, int type);{{{*/
-void  Penta::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols, int name, int type){
+void       Penta::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols, int name, int type){/*{{{*/
 
 	int             i,t,row;
@@ -3892,6 +3753,5 @@
 /*}}}*/
 #endif
-/*FUNCTION Penta::GetSolutionFromInputsOneDof {{{*/
-void Penta::GetSolutionFromInputsOneDof(Vector<IssmDouble>* solution, int enum_type){
+void       Penta::GetSolutionFromInputsOneDof(Vector<IssmDouble>* solution, int enum_type){/*{{{*/
 
 	const int    numdof=NDOF1*NUMVERTICES;
@@ -3923,6 +3783,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::MigrateGroundingLine{{{*/
-void  Penta::MigrateGroundingLine(IssmDouble* phi_ungrounding){
+void       Penta::MigrateGroundingLine(IssmDouble* phi_ungrounding){/*{{{*/
 
 	int        i,migration_style;
@@ -4028,6 +3887,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::PotentialUngrounding{{{*/
-void  Penta::PotentialUngrounding(Vector<IssmDouble>* potential_ungrounding){
+void       Penta::PotentialUngrounding(Vector<IssmDouble>* potential_ungrounding){/*{{{*/
 
 	IssmDouble  h[NUMVERTICES],r[NUMVERTICES],gl[NUMVERTICES];
@@ -4056,6 +3914,5 @@
 }
 /*}}}*/
-/*FUNCTION Penta::UpdatePotentialUngrounding{{{*/
-int Penta::UpdatePotentialUngrounding(IssmDouble* vertices_potentially_ungrounding,Vector<IssmDouble>* vec_nodes_on_iceshelf,IssmDouble* nodes_on_iceshelf){
+int        Penta::UpdatePotentialUngrounding(IssmDouble* vertices_potentially_ungrounding,Vector<IssmDouble>* vec_nodes_on_iceshelf,IssmDouble* nodes_on_iceshelf){/*{{{*/
 
 	int i;