Index: /issm/trunk/src/c/Container/DataSet.cpp
===================================================================
--- /issm/trunk/src/c/Container/DataSet.cpp	(revision 4926)
+++ /issm/trunk/src/c/Container/DataSet.cpp	(revision 4927)
@@ -234,10 +234,4 @@
 			dataset->AddObject(pentavertexinput);
 		}
-		else if(enum_type==BeamVertexInputEnum){
-			BeamVertexInput* beamvertexinput=NULL;
-			beamvertexinput=new BeamVertexInput();
-			beamvertexinput->Demarshall(&marshalled_dataset);
-			dataset->AddObject(beamvertexinput);
-		}
 		else if(enum_type==TriaVertexElementResultEnum){
 			TriaVertexElementResult* triavertexelementresult=NULL;
@@ -252,10 +246,4 @@
 			dataset->AddObject(pentavertexelementresult);
 		}
-		else if(enum_type==BeamEnum){
-			Beam* beam=NULL;
-			beam=new Beam();
-			beam->Demarshall(&marshalled_dataset);
-			dataset->AddObject(beam);
-		}
 		else if(enum_type==PentaEnum){
 			Penta* penta=NULL;
Index: /issm/trunk/src/c/Container/Inputs.cpp
===================================================================
--- /issm/trunk/src/c/Container/Inputs.cpp	(revision 4926)
+++ /issm/trunk/src/c/Container/Inputs.cpp	(revision 4927)
@@ -382,30 +382,4 @@
 }
 /*}}}*/
-/*FUNCTION Inputs::SpawnBeamInputs{{{1*/
-Inputs* Inputs::SpawnBeamInputs(int* indices){
-
-	/*Intermediary*/
-	vector<Object*>::iterator object;
-	Input* inputin=NULL;
-	Input* inputout=NULL;
-
-	/*Output*/
-	Inputs* newinputs=new Inputs();
-
-	/*Go through inputs and call Spawn function*/
-	for ( object=objects.begin() ; object < objects.end(); object++ ){
-
-		/*Create new input*/
-		inputin=(Input*)(*object); 
-		inputout=inputin->SpawnBeamInput(indices);
-
-		/*Add input to new inputs*/
-		newinputs->AddObject(inputout);
-	}
-
-	/*Assign output pointer*/
-	return newinputs;
-}
-/*}}}*/
 /*FUNCTION Inputs::SpawnTriaInputs{{{1*/
 Inputs* Inputs::SpawnTriaInputs(int* indices){
Index: /issm/trunk/src/c/Container/Inputs.h
===================================================================
--- /issm/trunk/src/c/Container/Inputs.h	(revision 4926)
+++ /issm/trunk/src/c/Container/Inputs.h	(revision 4927)
@@ -32,5 +32,4 @@
 		Input*  GetInput(int enum_name);
 		Inputs* SpawnTriaInputs(int* indices);
-		Inputs* SpawnBeamInputs(int* indices);
 		
 		void GetParameterValue(bool* pvalue,int enum_type);
Index: /issm/trunk/src/c/Container/Results.cpp
===================================================================
--- /issm/trunk/src/c/Container/Results.cpp	(revision 4926)
+++ /issm/trunk/src/c/Container/Results.cpp	(revision 4927)
@@ -43,30 +43,4 @@
 
 /*Object management*/
-/*FUNCTION Results::SpawnBeamResults{{{1*/
-Results* Results::SpawnBeamResults(int* indices){
-
-	/*Intermediary*/
-	vector<Object*>::iterator object;
-	ElementResult* resultin=NULL;
-	ElementResult* resultout=NULL;
-
-	/*Output*/
-	Results* newresults=new Results();
-
-	/*Go through results and call Spawn function*/
-	for ( object=objects.begin() ; object < objects.end(); object++ ){
-
-		/*Create new result*/
-		resultin=(ElementResult*)(*object); 
-		resultout=resultin->SpawnBeamElementResult(indices);
-
-		/*Add result to new results*/
-		newresults->AddObject((Object*)resultout);
-	}
-
-	/*Assign output pointer*/
-	return newresults;
-}
-/*}}}*/
 /*FUNCTION Results::SpawnTriaResults{{{1*/
 Results* Results::SpawnTriaResults(int* indices){
Index: /issm/trunk/src/c/Container/Results.h
===================================================================
--- /issm/trunk/src/c/Container/Results.h	(revision 4926)
+++ /issm/trunk/src/c/Container/Results.h	(revision 4927)
@@ -27,5 +27,4 @@
 		/*numerics: {{{1*/
 		Results* SpawnTriaResults(int* indices);
-		Results* SpawnBeamResults(int* indices);
 		/*}}}*/
 
Index: /issm/trunk/src/c/EnumDefinitions/EnumAsString.cpp
===================================================================
--- /issm/trunk/src/c/EnumDefinitions/EnumAsString.cpp	(revision 4926)
+++ /issm/trunk/src/c/EnumDefinitions/EnumAsString.cpp	(revision 4927)
@@ -84,5 +84,4 @@
 		case SegmentEnum : return "Segment";
 		case ElementEnum : return "Element";
-		case BeamEnum : return "Beam";
 		case DofIndexingEnum : return "DofIndexing";
 		case ElementPropertiesEnum : return "ElementProperties";
@@ -106,5 +105,4 @@
 		case MatparEnum : return "Matpar";
 		case InputEnum : return "Input";
-		case BeamVertexInputEnum : return "BeamVertexInput";
 		case BoolInputEnum : return "BoolInput";
 		case DoubleInputEnum : return "DoubleInput";
@@ -228,5 +226,4 @@
 		case TriaVertexElementResultEnum : return "TriaVertexElementResult";
 		case PentaVertexElementResultEnum : return "PentaVertexElementResult";
-		case BeamVertexElementResultEnum : return "BeamVertexElementResult";
 		case BoolExternalResultEnum : return "BoolExternalResult";
 		case DoubleExternalResultEnum : return "DoubleExternalResult";
Index: /issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h
===================================================================
--- /issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h	(revision 4926)
+++ /issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h	(revision 4927)
@@ -97,5 +97,4 @@
 	/*Elements: */
 	ElementEnum,
-	BeamEnum,
 	DofIndexingEnum,
 	ElementPropertiesEnum,
@@ -123,5 +122,4 @@
 	/*Inputs: */
 	InputEnum,
-	BeamVertexInputEnum,
 	BoolInputEnum,
 	DoubleInputEnum,
@@ -259,5 +257,4 @@
 	TriaVertexElementResultEnum,
 	PentaVertexElementResultEnum,
-	BeamVertexElementResultEnum,
 	BoolExternalResultEnum,
 	DoubleExternalResultEnum,
Index: /issm/trunk/src/c/EnumDefinitions/StringAsEnum.cpp
===================================================================
--- /issm/trunk/src/c/EnumDefinitions/StringAsEnum.cpp	(revision 4926)
+++ /issm/trunk/src/c/EnumDefinitions/StringAsEnum.cpp	(revision 4927)
@@ -82,5 +82,4 @@
 	else if (strcmp(name,"Segment")==0) return SegmentEnum;
 	else if (strcmp(name,"Element")==0) return ElementEnum;
-	else if (strcmp(name,"Beam")==0) return BeamEnum;
 	else if (strcmp(name,"DofIndexing")==0) return DofIndexingEnum;
 	else if (strcmp(name,"ElementProperties")==0) return ElementPropertiesEnum;
@@ -104,5 +103,4 @@
 	else if (strcmp(name,"Matpar")==0) return MatparEnum;
 	else if (strcmp(name,"Input")==0) return InputEnum;
-	else if (strcmp(name,"BeamVertexInput")==0) return BeamVertexInputEnum;
 	else if (strcmp(name,"BoolInput")==0) return BoolInputEnum;
 	else if (strcmp(name,"DoubleInput")==0) return DoubleInputEnum;
@@ -226,5 +224,4 @@
 	else if (strcmp(name,"TriaVertexElementResult")==0) return TriaVertexElementResultEnum;
 	else if (strcmp(name,"PentaVertexElementResult")==0) return PentaVertexElementResultEnum;
-	else if (strcmp(name,"BeamVertexElementResult")==0) return BeamVertexElementResultEnum;
 	else if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum;
 	else if (strcmp(name,"DoubleExternalResult")==0) return DoubleExternalResultEnum;
Index: /issm/trunk/src/c/Makefile.am
===================================================================
--- /issm/trunk/src/c/Makefile.am	(revision 4926)
+++ /issm/trunk/src/c/Makefile.am	(revision 4927)
@@ -114,6 +114,4 @@
 					./objects/ElementResults/PentaVertexElementResult.h\
 					./objects/ElementResults/PentaVertexElementResult.cpp\
-					./objects/ElementResults/BeamVertexElementResult.h\
-					./objects/ElementResults/BeamVertexElementResult.cpp\
 					./objects/ExternalResults/ExternalResult.h\
 					./objects/ExternalResults/BoolExternalResult.h\
@@ -141,6 +139,4 @@
 					./objects/Inputs/TriaVertexInput.h\
 					./objects/Inputs/TriaVertexInput.cpp\
-					./objects/Inputs/BeamVertexInput.h\
-					./objects/Inputs/BeamVertexInput.cpp\
 					./objects/Inputs/PentaVertexInput.h\
 					./objects/Inputs/PentaVertexInput.cpp\
@@ -151,6 +147,4 @@
 					./objects/Inputs/DoubleInput.h\
 					./objects/Inputs/DoubleInput.cpp\
-					./objects/Elements/Beam.h\
-					./objects/Elements/Beam.cpp\
 					./objects/Elements/BeamRef.h\
 					./objects/Elements/BeamRef.cpp\
@@ -672,6 +666,4 @@
 					./objects/ElementResults/PentaVertexElementResult.h\
 					./objects/ElementResults/PentaVertexElementResult.cpp\
-					./objects/ElementResults/BeamVertexElementResult.h\
-					./objects/ElementResults/BeamVertexElementResult.cpp\
 					./objects/ExternalResults/ExternalResult.h\
 					./objects/ExternalResults/BoolExternalResult.h\
@@ -699,6 +691,4 @@
 					./objects/Inputs/TriaVertexInput.h\
 					./objects/Inputs/TriaVertexInput.cpp\
-					./objects/Inputs/BeamVertexInput.h\
-					./objects/Inputs/BeamVertexInput.cpp\
 					./objects/Inputs/PentaVertexInput.h\
 					./objects/Inputs/PentaVertexInput.cpp\
@@ -709,6 +699,4 @@
 					./objects/Inputs/DoubleInput.h\
 					./objects/Inputs/DoubleInput.cpp\
-					./objects/Elements/Beam.h\
-					./objects/Elements/Beam.cpp\
 					./objects/Elements/BeamRef.h\
 					./objects/Elements/BeamRef.cpp\
Index: sm/trunk/src/c/objects/ElementResults/BeamVertexElementResult.cpp
===================================================================
--- /issm/trunk/src/c/objects/ElementResults/BeamVertexElementResult.cpp	(revision 4926)
+++ 	(revision )
@@ -1,167 +1,0 @@
-/*!\file BeamVertexElementResult.c
- * \brief: implementation of the BeamVertexElementResult object
- */
-
-#ifdef HAVE_CONFIG_H
-	#include "config.h"
-#else
-#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
-#endif
-
-#include "stdio.h"
-#include <string.h>
-#include "./ElementResultLocal.h"
-#include "../objects.h"
-#include "../../EnumDefinitions/EnumDefinitions.h"
-#include "../../shared/shared.h"
-#include "../../Container/Container.h"
-#include "../../include/include.h"
-
-/*BeamVertexElementResult constructors and destructor*/
-/*FUNCTION BeamVertexElementResult::BeamVertexElementResult(){{{1*/
-BeamVertexElementResult::BeamVertexElementResult(){
-	return;
-}
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::BeamVertexElementResult(int in_enum_type,double* in_values,int in_step, double in_time){{{1*/
-BeamVertexElementResult::BeamVertexElementResult(int in_enum_type,double* in_values,int in_step, double in_time){
-
-	enum_type=in_enum_type;
-	values[0]=in_values[0];
-	values[1]=in_values[1];
-	step=in_step;
-	time=in_time;
-}
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::~BeamVertexElementResult(){{{1*/
-BeamVertexElementResult::~BeamVertexElementResult(){
-	return;
-}
-/*}}}*/
-
-/*Object virtual functions definitions:*/
-/*FUNCTION BeamVertexElementResult::Echo {{{1*/
-void BeamVertexElementResult::Echo(void){
-	this->DeepEcho();
-}
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::DeepEcho{{{1*/
-void BeamVertexElementResult::DeepEcho(void){
-		
-	printf("BeamVertexElementResult:\n");
-	printf("   enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type));
-	printf("   values: [%g %g]\n",this->values[0],this->values[1]);
-	printf("   step: %i\n",this->step);
-	printf("   time: %g\n",this->time);
-
-}
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::Id{{{1*/
-int    BeamVertexElementResult::Id(void){ return -1; }
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::MyRank{{{1*/
-int    BeamVertexElementResult::MyRank(void){ 
-	extern int my_rank;
-	return my_rank; 
-}
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::Marshall{{{1*/
-void  BeamVertexElementResult::Marshall(char** pmarshalled_dataset){
-
-	char* marshalled_dataset=NULL;
-	int   enum_value=0;
-
-	/*recover marshalled_dataset: */
-	marshalled_dataset=*pmarshalled_dataset;
-
-	/*get enum value of BeamVertexElementResult: */
-	enum_value=BeamVertexElementResultEnum;
-	
-	/*marshall enum: */
-	memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value);
-	
-	/*marshall BeamVertexElementResult data: */
-	memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
-	memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values);
-	memcpy(marshalled_dataset,&time,sizeof(time));marshalled_dataset+=sizeof(time);
-	memcpy(marshalled_dataset,&step,sizeof(step));marshalled_dataset+=sizeof(step);
-
-	*pmarshalled_dataset=marshalled_dataset;
-}
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::MarshallSize{{{1*/
-int   BeamVertexElementResult::MarshallSize(){
-	
-	return sizeof(values)+
-		+sizeof(enum_type)
-		+sizeof(time)
-		+sizeof(step)
-		+sizeof(int); //sizeof(int) for enum value
-}
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::Demarshall{{{1*/
-void  BeamVertexElementResult::Demarshall(char** pmarshalled_dataset){
-
-	char* marshalled_dataset=NULL;
-	int   i;
-
-	/*recover marshalled_dataset: */
-	marshalled_dataset=*pmarshalled_dataset;
-
-	/*this time, no need to get enum type, the pointer directly points to the beginning of the 
-	 *object data (thanks to DataSet::Demarshall):*/
-	memcpy(&enum_type,marshalled_dataset,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
-	memcpy(&values,marshalled_dataset,sizeof(values));marshalled_dataset+=sizeof(values);
-	memcpy(&time,marshalled_dataset,sizeof(time));marshalled_dataset+=sizeof(time);
-	memcpy(&step,marshalled_dataset,sizeof(step));marshalled_dataset+=sizeof(step);
-
-	/*return: */
-	*pmarshalled_dataset=marshalled_dataset;
-	return;
-}
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::Enum{{{1*/
-int BeamVertexElementResult::Enum(void){
-
-	return BeamVertexElementResultEnum;
-
-}
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::copy{{{1*/
-Object* BeamVertexElementResult::copy() {
-	
-	return new BeamVertexElementResult(this->enum_type,this->values,this->step,this->time);
-
-}
-/*}}}*/
-
-/*ElementResult management*/
-/*FUNCTION BeamVertexElementResult::EnumType{{{1*/
-int BeamVertexElementResult::EnumType(void){
-
-	return this->enum_type;
-
-}
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::ProcessUnits{{{1*/
-void BeamVertexElementResult::ProcessUnits(Parameters* parameters){
-	
-	NodalValuesUnitConversion(this->values,2,this->enum_type,parameters);
-
-}
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::NumberOfNodalValues{{{1*/
-int BeamVertexElementResult::NumberOfNodalValues(void){
-	return 2;
-}
-/*}}}*/
-/*FUNCTION BeamVertexElementResult::PatchFill{{{1*/
-void BeamVertexElementResult::PatchFill(int row, Patch* patch){
-	
-	 /*Here, we fill the result information into the patch object. First, let's remember what is in a row 
-	  * of the patch object: enum_type step time element_id interpolation vertices_ids nodal_values
-	  * Here, we will supply the enum_type, step, time, interpolation and nodal_values: */
-	patch->fillresultinfo(row,this->enum_type,this->step,this->time,P1Enum,this->values,2);
-
-}
-/*}}}*/
Index: sm/trunk/src/c/objects/ElementResults/BeamVertexElementResult.h
===================================================================
--- /issm/trunk/src/c/objects/ElementResults/BeamVertexElementResult.h	(revision 4926)
+++ 	(revision )
@@ -1,53 +1,0 @@
-/*! \file BeamVertexElementResult.h 
- *  \brief: header file for triavertexresult object
- */
-
-
-#ifndef _BEAMVERTEXELEMENTRESULT_H_
-#define _BEAMVERTEXELEMENTRESULT_H_
-
-/*Headers:*/
-/*{{{1*/
-#include "../Inputs/Input.h"
-#include "../../include/include.h"
-/*}}}*/
-
-class BeamVertexElementResult: public ElementResult{
-
-	private: 
-		int    enum_type;
-		double values[2];
-		int    step;
-		double time;
-
-	public:
-
-		/*BeamVertexElementResult constructors, destructors: {{{1*/
-		BeamVertexElementResult();
-		BeamVertexElementResult(int enum_type,double* values,int step,double time);
-		~BeamVertexElementResult();
-		/*}}}*/
-		/*Object virtual functions definitions:{{{1 */
-		void  Echo();
-		void  DeepEcho();
-		int   Id(); 
-		int   MyRank();
-		void  Marshall(char** pmarshalled_dataset);
-		int   MarshallSize();
-		void  Demarshall(char** pmarshalled_dataset);
-		int   Enum();
-		Object* copy();
-		/*}}}*/
-		/*ElementResult virtual functions definitions: {{{1*/
-		ElementResult* SpawnBeamElementResult(int* indices){ISSMERROR("Not implemented yet!");}
-		ElementResult* SpawnTriaElementResult(int* indices){ISSMERROR("Not implemented yet!");}
-		void    ProcessUnits(Parameters* parameters);
-		int     NumberOfNodalValues(void);
-		void    PatchFill(int row, Patch* patch);
-		/*}}}*/
-		/*BeamVertexElementResult management: {{{1*/
-		int   EnumType();
-		/*}}}*/
-
-};
-#endif  /* _BEAMVERTEXELEMENTRESULT_H */
Index: /issm/trunk/src/c/objects/ElementResults/DoubleElementResult.cpp
===================================================================
--- /issm/trunk/src/c/objects/ElementResults/DoubleElementResult.cpp	(revision 4926)
+++ /issm/trunk/src/c/objects/ElementResults/DoubleElementResult.cpp	(revision 4927)
@@ -142,22 +142,4 @@
 }
 /*}}}*/
-/*FUNCTION DoubleElementResult::SpawnBeamElementResult{{{1*/
-ElementResult* DoubleElementResult::SpawnBeamElementResult(int* indices){
-
-	/*output*/
-	DoubleElementResult* outresult=new DoubleElementResult();
-
-	/*copy fields: */
-	outresult->enum_type=this->enum_type;
-	outresult->value=this->value;
-	outresult->time=this->time;
-	outresult->step=this->step;
-
-
-	/*Assign output*/
-	return outresult;
-
-}
-/*}}}*/
 /*FUNCTION DoubleElementResult::SpawnTriaElementResult{{{1*/
 ElementResult* DoubleElementResult::SpawnTriaElementResult(int* indices){
Index: /issm/trunk/src/c/objects/ElementResults/DoubleElementResult.h
===================================================================
--- /issm/trunk/src/c/objects/ElementResults/DoubleElementResult.h	(revision 4926)
+++ /issm/trunk/src/c/objects/ElementResults/DoubleElementResult.h	(revision 4927)
@@ -42,5 +42,4 @@
 		/*}}}*/
 		/*ElementResult virtual functions definitions: {{{1*/
-		ElementResult* SpawnBeamElementResult(int* indices);
 		ElementResult* SpawnTriaElementResult(int* indices);
 		void    ProcessUnits(Parameters* parameters);
Index: /issm/trunk/src/c/objects/ElementResults/ElementResult.h
===================================================================
--- /issm/trunk/src/c/objects/ElementResults/ElementResult.h	(revision 4926)
+++ /issm/trunk/src/c/objects/ElementResults/ElementResult.h	(revision 4927)
@@ -18,5 +18,4 @@
 		virtual        ~ElementResult(){};
 		
-		virtual         ElementResult* SpawnBeamElementResult(int* indices)=0;
 		virtual         ElementResult* SpawnTriaElementResult(int* indices)=0;
 		virtual void    ProcessUnits(Parameters* parameters)=0;
Index: /issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.cpp
===================================================================
--- /issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.cpp	(revision 4926)
+++ /issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.cpp	(revision 4927)
@@ -145,29 +145,4 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexElementResult::SpawnBeamElementResult{{{1*/
-ElementResult* PentaVertexElementResult::SpawnBeamElementResult(int* indices){
-
-	/*output*/
-	BeamVertexElementResult* outresult=NULL;
-	double newvalues[2];
-
-	/*Loop over the new indices*/
-	for(int i=0;i<2;i++){
-
-		/*Check index value*/
-		ISSMASSERT(indices[i]>=0 && indices[i]<6);
-
-		/*Assign value to new result*/
-		newvalues[i]=this->values[indices[i]];
-	}
-
-	/*Create new Beam result*/
-	outresult=new BeamVertexElementResult(this->enum_type,&newvalues[0],this->step,this->time);
-
-	/*Assign output*/
-	return outresult;
-
-}
-/*}}}*/
 /*FUNCTION PentaVertexElementResult::SpawnTriaElementResult{{{1*/
 ElementResult* PentaVertexElementResult::SpawnTriaElementResult(int* indices){
Index: /issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.h
===================================================================
--- /issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.h	(revision 4926)
+++ /issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.h	(revision 4927)
@@ -41,5 +41,4 @@
 		/*}}}*/
 		/*ElementResult virtual functions definitions: {{{1*/
-		ElementResult* SpawnBeamElementResult(int* indices);
 		ElementResult* SpawnTriaElementResult(int* indices);
 		void    ProcessUnits(Parameters* parameters);
Index: /issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.cpp
===================================================================
--- /issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.cpp	(revision 4926)
+++ /issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.cpp	(revision 4927)
@@ -145,29 +145,4 @@
 }
 /*}}}*/
-/*FUNCTION BeamVertexElementResult::SpawnBeamElementResult{{{1*/
-ElementResult* TriaVertexElementResult::SpawnBeamElementResult(int* indices){
-
-	/*output*/
-	BeamVertexElementResult* outresult=NULL;
-	double newvalues[2];
-
-	/*Loop over the new indices*/
-	for(int i=0;i<2;i++){
-
-		/*Check index value*/
-		ISSMASSERT(indices[i]>=0 && indices[i]<3);
-
-		/*Assign value to new result*/
-		newvalues[i]=this->values[indices[i]];
-	}
-
-	/*Create new Beam result*/
-	outresult=new BeamVertexElementResult(this->enum_type,&newvalues[0],this->step,this->time);
-
-	/*Assign output*/
-	return outresult;
-
-}
-/*}}}*/
 /*FUNCTION TriaVertexElementResult::SpawnTriaElementResult{{{1*/
 ElementResult* TriaVertexElementResult::SpawnTriaElementResult(int* indices){
Index: /issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.h
===================================================================
--- /issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.h	(revision 4926)
+++ /issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.h	(revision 4927)
@@ -40,5 +40,4 @@
 		/*}}}*/
 		/*ElementResult virtual functions definitions: {{{1*/
-		ElementResult* SpawnBeamElementResult(int* indices);
 		ElementResult* SpawnTriaElementResult(int* indices);
 		void    ProcessUnits(Parameters* parameters);
Index: sm/trunk/src/c/objects/Elements/Beam.cpp
===================================================================
--- /issm/trunk/src/c/objects/Elements/Beam.cpp	(revision 4926)
+++ 	(revision )
@@ -1,996 +1,0 @@
-/*!\file Beam.c
- * \brief: implementation of the Beam object
- */
-
-#ifdef HAVE_CONFIG_H
-	#include "config.h"
-#else
-#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
-#endif
-
-#include "stdio.h"
-#include <string.h>
-#include "../objects.h"
-#include "../../EnumDefinitions/EnumDefinitions.h"
-#include "../../shared/shared.h"
-#include "../../Container/Container.h"
-#include "../../include/include.h"
-
-/*Beam constructors and destructor*/
-/*FUNCTION Beam::Beam(){{{1*/
-Beam::Beam(){
-	this->inputs=NULL;
-	this->parameters=NULL;
-	return;
-}
-/*}}}*/
-/*FUNCTION Beam::~Beam(){{{1*/
-Beam::~Beam(){
-	delete inputs;
-	this->parameters=NULL;
-}
-/*}}}*/
-
-/*Object virtual functions definitions:*/
-/*FUNCTION Beam::copy{{{1*/
-Object* Beam::copy() {
-
-	int i;
-	Beam* beam=NULL;
-
-	beam=new Beam();
-
-	/*copy fields: */
-	beam->id=this->id;
-	if(this->inputs){
-		beam->inputs=(Inputs*)this->inputs->Copy();
-	}
-	else{
-		beam->inputs=new Inputs();
-	}
-	/*point parameters: */
-	beam->parameters=this->parameters;
-
-	/*pointers: */
-	beam->nodes=(Node**)xmalloc(2*sizeof(Node*)); 
-	for(i=0;i<2;i++)beam->nodes[i]=this->nodes[i];
-	beam->matice=this->matice;
-	beam->matpar=this->matpar;
-
-	return beam;
-}
-/*}}}*/
-/*FUNCTION Beam::DeepEcho{{{1*/
-void Beam::DeepEcho(void){
-
-	int i;
-
-	printf("Beam:\n");
-	printf("   id: %i\n",id);
-	for(i=0;i<2;i++){
-		nodes[i]->DeepEcho();
-	}
-	matice->DeepEcho();
-	matpar->DeepEcho();
-	printf("   parameters\n");
-	parameters->DeepEcho();
-	printf("   inputs\n");
-	inputs->DeepEcho();
-
-	return;
-}
-/*}}}*/
-/*FUNCTION Beam::Demarshall{{{1*/
-void  Beam::Demarshall(char** pmarshalled_dataset){
-	ISSMERROR("not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::Echo {{{1*/
-void Beam::Echo(void){
-
-	int i;
-
-	printf("Beam:\n");
-	printf("   id: %i\n",id);
-	for(i=0;i<2;i++){
-		nodes[i]->DeepEcho();
-	}
-	matice->DeepEcho();
-	matpar->DeepEcho();
-	printf("   parameters\n");
-	parameters->Echo();
-	printf("   inputs\n");
-	inputs->Echo();
-
-	return;
-}
-/*}}}*/
-/*FUNCTION Beam::Enum{{{1*/
-int Beam::Enum(void){
-
-	return BeamEnum;
-
-}
-/*}}}*/
-/*FUNCTION Beam::Id{{{1*/
-int    Beam::Id(void){ return id; }
-/*}}}*/
-/*FUNCTION Beam::Marshall{{{1*/
-void  Beam::Marshall(char** pmarshalled_dataset){
-	ISSMERROR("not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::MarshallSize{{{1*/
-int   Beam::MarshallSize(){
-	ISSMERROR("not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::MyRank{{{1*/
-int    Beam::MyRank(void){ 
-	extern int my_rank;
-	return my_rank; 
-}
-/*}}}*/
-
-/*Update virtual functions definitions:*/
-/*FUNCTION Beam::InputUpdateFromVector(double* vector, int name, int type);{{{1*/
-void  Beam::InputUpdateFromVector(double* vector, int name, int type){
-
-	/*Check that name is an element input*/
-	if (!IsInput(name)) return;
-	switch(type){
-
-		case VertexEnum:
-
-			/*New PentaVertexInpu*/
-			double values[2];
-
-			/*Get values on the 6 vertices*/
-			for (int i=0;i<2;i++){
-				values[i]=vector[nodes[i]->GetVertexDof()];
-			}
-
-			/*update input*/
-			this->inputs->AddInput(new BeamVertexInput(name,values));
-			return;
-
-		default:
-
-			ISSMERROR("type %i (%s) not implemented yet",type,EnumAsString(type));
-	}
-}
-/*}}}*/
-/*FUNCTION Beam::InputUpdateFromVector(int* vector, int name, int type);{{{1*/
-void  Beam::InputUpdateFromVector(int* vector, int name, int type){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::InputUpdateFromVector(bool* vector, int name, int type);{{{1*/
-void  Beam::InputUpdateFromVector(bool* vector, int name, int type){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::InputUpdateFromSolution {{{1*/
-void  Beam::InputUpdateFromSolution(double* solution){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-
-/*Element virtual functions definitions:*/
-/*FUNCTION Beam::ComputeBasalStress{{{1*/
-void  Beam::ComputeBasalStress(Vec eps){
-
-	ISSMERROR("Not implemented yet");
-
-}
-/*}}}*/
-/*FUNCTION Beam::ComputePressure{{{1*/
-void  Beam::ComputePressure(Vec p_g){
-
-	int i;
-	const int numgrids=2;
-	int doflist[numgrids];
-	double pressure[numgrids];
-	double surface[numgrids];
-	double rho_ice,g;
-	double xyz_list[numgrids][3];
-	double gauss[numgrids][numgrids]={{1,0},{0,1}};
-	int    analysis_type;
-
-	/*retrive parameters: */
-	parameters->FindParam(&analysis_type,AnalysisTypeEnum);
-
-	/*Get dof list on which we will plug the pressure values: */
-	GetDofList1(&doflist[0]);
-
-	/*Get node data: */
-	GetVerticesCoordinates(&xyz_list[0][0], nodes, numgrids);
-        
-	/*Get dof list on which we will plug the pressure values: */
-	GetDofList1(&doflist[0]);
-
-	/*pressure is lithostatic: */
-	rho_ice=matpar->GetRhoIce();
-	g=matpar->GetG();
-
-	/*recover value of surface at gauss points (0,1) and (1,0): */
-	inputs->GetParameterValues(&surface[0],&gauss[0][0],2,SurfaceEnum);
-	for(i=0;i<numgrids;i++){
-		pressure[i]=rho_ice*g*(surface[i]-xyz_list[i][2]);
-	}
-
-	/*plug local pressure values into global pressure vector: */
-	VecSetValues(p_g,numgrids,doflist,(const double*)pressure,INSERT_VALUES);
-
-}
-/*}}}*/
-/*FUNCTION Beam::ComputeStrainRate{{{1*/
-void  Beam::ComputeStrainRate(Vec eps){
-
-	ISSMERROR("Not implemented yet");
-
-}
-/*}}}*/
-/*FUNCTION Beam::Configure {{{1*/
-void  Beam::Configure(Elements* elementsin,Loads* loadsin, DataSet* nodesin, Materials* materialsin, Parameters* parametersin){
-
-	ISSMERROR(" not supported yet!");
-
-}
-/*}}}*/
-/*FUNCTION Beam::SetCurrentConfiguration {{{1*/
-void  Beam::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin, DataSet* nodesin, Materials* materialsin, Parameters* parametersin){
-
-	ISSMERROR(" not supported yet!");
-
-}
-/*}}}*/
-/*FUNCTION Beam::CostFunction{{{1*/
-double Beam::CostFunction(void){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::CreatePVector{{{1*/
-void  Beam::CreatePVector(Vec pg){
-
-	int analysis_type;
-
-	/*retrive parameters: */
-	parameters->FindParam(&analysis_type,AnalysisTypeEnum);
-	
-	/*Just branch to the correct load generator, according to the type of analysis we are carrying out: */
-	if (analysis_type==DiagnosticHutterAnalysisEnum) {
-		CreatePVectorDiagnosticHutter( pg);
-	}
-	else{
-		ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumAsString(analysis_type));
-	}
-
-}
-/*}}}*/
-/*FUNCTION Beam::DeleteResults {{{1*/
-void  Beam::DeleteResults(void){
-
-	ISSMERROR("not implemented yet");
-
-}
-/*}}}*/
-/*FUNCTION Beam::GetBedList{{{1*/
-void  Beam::GetBedList(double*){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::GetMatPar{{{1*/
-void* Beam::GetMatPar(){
-
-	return matpar;
-}
-/*}}}*/
-/*FUNCTION Beam::GetNodes{{{1*/
-void  Beam::GetNodes(void** vpnodes){
-	int i;
-	Node** pnodes=NULL;
-
-	/*recover nodes: */
-	pnodes=(Node**)vpnodes;
-
-	for(i=0;i<3;i++){
-		pnodes[i]=nodes[i];
-	}
-}
-/*}}}*/
-/*FUNCTION Beam::GetOnBed{{{1*/
-bool   Beam::GetOnBed(){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::GetShelf{{{1*/
-bool   Beam::GetShelf(){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::GetSolutionFromInputs{{{1*/
-void  Beam::GetSolutionFromInputs(Vec solution){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::GetThicknessList{{{1*/
-void  Beam::GetThicknessList(double* thickness_list){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::GetVectorFromInputs{{{1*/
-void  Beam::GetVectorFromInputs(Vec vector,int NameEnum){
-
-	int i;
-	const int numvertices=2;
-	int doflist1[numvertices];
-
-	/*Find NameEnum input in the inputs dataset, and get it to fill in the vector: */
-	for(i=0;i<this->inputs->Size();i++){
-		Input* input=(Input*)this->inputs->GetObjectByOffset(i);
-		if(input->EnumType()==NameEnum){
-			/*We found the enum.  Use its values to fill into the vector, using the vertices ids: */
-			this->GetDofList1(&doflist1[0]);
-			input->GetVectorFromInputs(vector,&doflist1[0]);
-			break;
-		}
-	}
-}
-/*}}}*/
-/*FUNCTION Beam::Gradj{{{1*/
-void  Beam::Gradj(Vec gradient,int control_type){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::GradjB{{{1*/
-void  Beam::GradjB(Vec gradient){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::GradjDrag{{{1*/
-void  Beam::GradjDrag(Vec gradient){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::InputAXPY{{{1*/
-void  Beam::InputAXPY(int YEnum, double scalar, int XEnum){
-
-	Input* xinput=NULL;
-	Input* yinput=NULL;
-
-	/*Find x and y inputs: */
-	xinput=(Input*)this->inputs->GetInput(XEnum);
-	yinput=(Input*)this->inputs->GetInput(YEnum);
-
-	/*some checks: */
-	if(!xinput || !yinput)ISSMERROR("%s%s%s%s%s"," input ",EnumAsString(XEnum)," or input ",EnumAsString(YEnum)," could not be found!");
-	if(xinput->Enum()!=yinput->Enum())ISSMERROR("%s%s%s%s%s"," input ",EnumAsString(XEnum)," and input ",EnumAsString(YEnum)," are not of the same type!");
-
-	/*Scale: */
-	yinput->AXPY(xinput,scalar);
-}
-/*}}}*/
-/*FUNCTION Beam::InputControlConstrain{{{1*/
-void  Beam::InputControlConstrain(int control_type, double cm_min, double cm_max){
-
-	Input* input=NULL;
-
-	/*Find input: */
-	input=(Input*)this->inputs->GetInput(control_type);
-	
-	/*Do nothing if we  don't find it: */
-	if(!input)return;
-
-	/*Constrain input using cm_min and cm_max: */
-	input->Constrain(cm_min,cm_max);
-
-}
-/*}}}*/
-/*FUNCTION Beam::InputConvergence{{{1*/
-bool Beam::InputConvergence(double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums){
-
-	int i;
-	Input** new_inputs=NULL;
-	Input** old_inputs=NULL;
-	bool    converged=true;
-
-	new_inputs=(Input**)xmalloc(num_enums/2*sizeof(Input*)); //half the enums are for the new inputs
-	old_inputs=(Input**)xmalloc(num_enums/2*sizeof(Input*)); //half the enums are for the old inputs
-
-	for(i=0;i<num_enums/2;i++){
-		new_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+0]);
-		old_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+1]);
-		if(!new_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumAsString(enums[2*i+0]));
-		if(!old_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumAsString(enums[2*i+0]));
-	}
-
-	/*ok, we've got the inputs (new and old), now loop throught the number of criterions and fill the eps array:*/
-	for(i=0;i<num_criterionenums;i++){
-		IsInputConverged(eps+i,new_inputs,old_inputs,num_enums/2,criterionenums[i]);
-		if(eps[i]>criterionvalues[i]) converged=false; 
-	}
-
-	/*clean up*/
-	xfree((void**)&new_inputs);
-	xfree((void**)&old_inputs);
-
-	/*Return output*/
-	return converged;
-
-}
-/*}}}*/
-/*FUNCTION Beam::InputDuplicate{{{1*/
-void  Beam::InputDuplicate(int original_enum,int new_enum){
-
-	Input* original=NULL;
-	Input* copy=NULL;
-
-	/*Make a copy of the original input: */
-	original=(Input*)this->inputs->GetInput(original_enum);
-	copy=(Input*)original->copy();
-
-	/*Change copy enum to reinitialized_enum: */
-	copy->ChangeEnum(new_enum);
-
-	/*Add copy into inputs, it will wipe off the one already there: */
-	inputs->AddObject((Input*)copy);
-}
-/*}}}*/
-/*FUNCTION Beam::InputScale{{{1*/
-void  Beam::InputScale(int enum_type,double scale_factor){
-
-	Input* input=NULL;
-
-	/*Make a copy of the original input: */
-	input=(Input*)this->inputs->GetInput(enum_type);
-
-	/*Scale: */
-	input->Scale(scale_factor);
-}
-/*}}}*/
-/*FUNCTION Beam::InputToResult{{{1*/
-void  Beam::InputToResult(int enum_type,int step,double time){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::MassFlux{{{1*/
-double Beam::MassFlux( double* segment){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::MaxAbsVx{{{1*/
-void  Beam::MaxAbsVx(double* pmaxabsvx, bool process_units){
-
-	int i;
-	int dim;
-	const int numgrids=2;
-	double  gaussgrids[numgrids][2]={{0,1},{1,0}};
-	double  vx_values[numgrids];
-	double  maxabsvx;
-
-	/*retrieve dim parameter: */
-	parameters->FindParam(&dim,DimEnum);
-
-	/*retrive velocity values at nodes */
-	inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
-
-	/*process units if requested: */
-	if(process_units)NodalValuesUnitConversion(&vx_values[0],numgrids,VxEnum,this->parameters);
-
-	/*now, compute maximum:*/
-	maxabsvx=fabs(vx_values[0]);
-	for(i=1;i<numgrids;i++){
-		if (fabs(vx_values[i])>maxabsvx)maxabsvx=fabs(vx_values[i]);
-	}
-
-	/*Assign output pointers:*/
-	*pmaxabsvx=maxabsvx;
-}
-/*}}}*/
-/*FUNCTION Beam::MaxAbsVy{{{1*/
-void  Beam::MaxAbsVy(double* pmaxabsvy, bool process_units){
-
-	int i;
-	int dim;
-	const int numgrids=2;
-	double  gaussgrids[numgrids][2]={{0,1},{1,0}};
-	double  vy_values[numgrids];
-	double  maxabsvy;
-
-	/*retrieve dim parameter: */
-	parameters->FindParam(&dim,DimEnum);
-
-	/*retrive velocity values at nodes */
-	inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
-
-	/*process units if requested: */
-	if(process_units)NodalValuesUnitConversion(&vy_values[0],numgrids,VyEnum,this->parameters);
-
-	/*now, compute maximum:*/
-	maxabsvy=fabs(vy_values[0]);
-	for(i=1;i<numgrids;i++){
-		if (fabs(vy_values[i])>maxabsvy)maxabsvy=fabs(vy_values[i]);
-	}
-
-	/*Assign output pointers:*/
-	*pmaxabsvy=maxabsvy;
-}
-/*}}}*/
-/*FUNCTION Beam::MaxAbsVz{{{1*/
-void  Beam::MaxAbsVz(double* pmaxabsvz, bool process_units){
-
-	int i;
-	int dim;
-	const int numgrids=2;
-	double  gaussgrids[numgrids][2]={{0,1},{1,0}};
-	double  vz_values[numgrids];
-	double  maxabsvz;
-
-	/*retrieve dim parameter: */
-	parameters->FindParam(&dim,DimEnum);
-
-	/*retrive velocity values at nodes */
-	inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
-
-	/*process units if requested: */
-	if(process_units)NodalValuesUnitConversion(&vz_values[0],numgrids,VzEnum,this->parameters);
-
-	/*now, compute maximum:*/
-	maxabsvz=fabs(vz_values[0]);
-	for(i=1;i<numgrids;i++){
-		if (fabs(vz_values[i])>maxabsvz)maxabsvz=fabs(vz_values[i]);
-	}
-
-	/*Assign output pointers:*/
-	*pmaxabsvz=maxabsvz;
-}
-/*}}}*/
-/*FUNCTION Beam::MaxVel{{{1*/
-void  Beam::MaxVel(double* pmaxvel, bool process_units){
-
-	int i;
-	int dim;
-	const int numgrids=2;
-	double  gaussgrids[numgrids][2]={{0,1},{1,0}};
-	double  vel_values[numgrids];
-	double  maxvel;
-
-	/*retrieve dim parameter: */
-	parameters->FindParam(&dim,DimEnum);
-
-	/*retrive velocity values at nodes */
-	inputs->GetParameterValues(&vel_values[0],&gaussgrids[0][0],numgrids,VelEnum);
-
-	/*process units if requested: */
-	if(process_units)NodalValuesUnitConversion(&vel_values[0],numgrids,VelEnum,this->parameters);
-
-	/*now, compute maximum:*/
-	maxvel=vel_values[0];
-	for(i=1;i<numgrids;i++){
-		if (vel_values[i]>maxvel)maxvel=vel_values[i];
-	}
-
-	/*Assign output pointers:*/
-	*pmaxvel=maxvel;
-
-}
-/*}}}*/
-/*FUNCTION Beam::MaxVx{{{1*/
-void  Beam::MaxVx(double* pmaxvx, bool process_units){
-
-	int i;
-	int dim;
-	const int numgrids=2;
-	double  gaussgrids[numgrids][2]={{0,1},{1,0}};
-	double  vx_values[numgrids];
-	double  maxvx;
-
-	/*retrieve dim parameter: */
-	parameters->FindParam(&dim,DimEnum);
-
-	/*retrive velocity values at nodes */
-	inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
-
-	/*process units if requested: */
-	if(process_units)NodalValuesUnitConversion(&vx_values[0],numgrids,VxEnum,this->parameters);
-
-	/*now, compute maximum:*/
-	maxvx=vx_values[0];
-	for(i=1;i<numgrids;i++){
-		if (vx_values[i]>maxvx)maxvx=vx_values[i];
-	}
-
-	/*Assign output pointers:*/
-	*pmaxvx=maxvx;
-
-}
-/*}}}*/
-/*FUNCTION Beam::MaxVy{{{1*/
-void  Beam::MaxVy(double* pmaxvy, bool process_units){
-
-	int i;
-	int dim;
-	const int numgrids=2;
-	double  gaussgrids[numgrids][2]={{0,1},{1,0}};
-	double  vy_values[numgrids];
-	double  maxvy;
-
-	/*retrieve dim parameter: */
-	parameters->FindParam(&dim,DimEnum);
-
-	/*retrive velocity values at nodes */
-	inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
-
-	/*process units if requested: */
-	if(process_units)NodalValuesUnitConversion(&vy_values[0],numgrids,VyEnum,this->parameters);
-
-	/*now, compute maximum:*/
-	maxvy=vy_values[0];
-	for(i=1;i<numgrids;i++){
-		if (vy_values[i]>maxvy)maxvy=vy_values[i];
-	}
-
-	/*Assign output pointers:*/
-	*pmaxvy=maxvy;
-
-}
-/*}}}*/
-/*FUNCTION Beam::MaxVz{{{1*/
-void  Beam::MaxVz(double* pmaxvz, bool process_units){
-
-	int i;
-	int dim;
-	const int numgrids=2;
-	double  gaussgrids[numgrids][2]={{0,1},{1,0}};
-	double  vz_values[numgrids];
-	double  maxvz;
-
-	/*retrieve dim parameter: */
-	parameters->FindParam(&dim,DimEnum);
-
-	/*retrive velocity values at nodes */
-	inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
-
-	/*process units if requested: */
-	if(process_units)NodalValuesUnitConversion(&vz_values[0],numgrids,VzEnum,this->parameters);
-
-	/*now, compute maximum:*/
-	maxvz=vz_values[0];
-	for(i=1;i<numgrids;i++){
-		if (vz_values[i]>maxvz)maxvz=vz_values[i];
-	}
-
-	/*Assign output pointers:*/
-	*pmaxvz=maxvz;
-
-}
-/*}}}*/
-/*FUNCTION Beam::MinVel{{{1*/
-void  Beam::MinVel(double* pminvel, bool process_units){
-
-	int i;
-	int dim;
-	const int numgrids=2;
-	double  gaussgrids[numgrids][2]={{0,1},{1,0}};
-	double  vel_values[numgrids];
-	double  minvel;
-
-	/*retrieve dim parameter: */
-	parameters->FindParam(&dim,DimEnum);
-
-	/*retrive velocity values at nodes */
-	inputs->GetParameterValues(&vel_values[0],&gaussgrids[0][0],numgrids,VelEnum);
-
-	/*process units if requested: */
-	if(process_units)NodalValuesUnitConversion(&vel_values[0],numgrids,VelEnum,this->parameters);
-
-	/*now, compute minimum:*/
-	minvel=vel_values[0];
-	for(i=1;i<numgrids;i++){
-		if (vel_values[i]<minvel)minvel=vel_values[i];
-	}
-
-	/*Assign output pointers:*/
-	*pminvel=minvel;
-
-}
-/*}}}*/
-/*FUNCTION Beam::MinVx{{{1*/
-void  Beam::MinVx(double* pminvx, bool process_units){
-
-	int i;
-	int dim;
-	const int numgrids=2;
-	double  gaussgrids[numgrids][2]={{0,1},{1,0}};
-	double  vx_values[numgrids];
-	double  minvx;
-
-	/*retrieve dim parameter: */
-	parameters->FindParam(&dim,DimEnum);
-
-	/*retrive velocity values at nodes */
-	inputs->GetParameterValues(&vx_values[0],&gaussgrids[0][0],numgrids,VxEnum);
-
-	/*process units if requested: */
-	if(process_units)NodalValuesUnitConversion(&vx_values[0],numgrids,VxEnum,this->parameters);
-
-	/*now, compute minimum:*/
-	minvx=vx_values[0];
-	for(i=1;i<numgrids;i++){
-		if (vx_values[i]<minvx)minvx=vx_values[i];
-	}
-
-	/*Assign output pointers:*/
-	*pminvx=minvx;
-
-}
-/*}}}*/
-/*FUNCTION Beam::MinVy{{{1*/
-void  Beam::MinVy(double* pminvy, bool process_units){
-
-	int i;
-	int dim;
-	const int numgrids=2;
-	double  gaussgrids[numgrids][2]={{0,1},{1,0}};
-	double  vy_values[numgrids];
-	double  minvy;
-
-	/*retrieve dim parameter: */
-	parameters->FindParam(&dim,DimEnum);
-
-	/*retrive velocity values at nodes */
-	inputs->GetParameterValues(&vy_values[0],&gaussgrids[0][0],numgrids,VyEnum);
-
-	/*process units if requested: */
-	if(process_units)NodalValuesUnitConversion(&vy_values[0],numgrids,VyEnum,this->parameters);
-
-	/*now, compute minimum:*/
-	minvy=vy_values[0];
-	for(i=1;i<numgrids;i++){
-		if (vy_values[i]<minvy)minvy=vy_values[i];
-	}
-
-	/*Assign output pointers:*/
-	*pminvy=minvy;
-
-}
-/*}}}*/
-/*FUNCTION Beam::MinVz{{{1*/
-void  Beam::MinVz(double* pminvz, bool process_units){
-
-	int i;
-	int dim;
-	const int numgrids=2;
-	double  gaussgrids[numgrids][2]={{0,1},{1,0}};
-	double  vz_values[numgrids];
-	double  minvz;
-
-	/*retrieve dim parameter: */
-	parameters->FindParam(&dim,DimEnum);
-
-	/*retrive velocity values at nodes */
-	inputs->GetParameterValues(&vz_values[0],&gaussgrids[0][0],numgrids,VzEnum);
-
-	/*process units if requested: */
-	if(process_units)NodalValuesUnitConversion(&vz_values[0],numgrids,VzEnum,this->parameters);
-
-	/*now, compute minimum:*/
-	minvz=vz_values[0];
-	for(i=1;i<numgrids;i++){
-		if (vz_values[i]<minvz)minvz=vz_values[i];
-	}
-
-	/*Assign output pointers:*/
-	*pminvz=minvz;
-
-}
-/*}}}*/
-/*FUNCTION Beam::Misfit{{{1*/
-double Beam::Misfit(void){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::PatchFill{{{1*/
-void  Beam::PatchFill(int* pcount, Patch* patch){
-
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::PatchSize{{{1*/
-void  Beam::PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes){
-
-	ISSMERROR(" not supported yet!");
-	
-}
-/*}}}*/
-/*FUNCTION Beam::ProcessResultsUnits{{{1*/
-void  Beam::ProcessResultsUnits(void){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::SurfaceArea{{{1*/
-double Beam::SurfaceArea(void){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-/*FUNCTION Beam::Update{{{1*/
-void Beam::Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type){
-	ISSMERROR(" not supported yet!");
-}
-/*}}}*/
-
-/*Beam specific routines: */
-/*FUNCTION Beam::CreatePVectorDiagnosticHutter{{{1*/
-
-void Beam::CreatePVectorDiagnosticHutter( Vec pg){
-
-	int i,j,k;
-	
-	const int numgrids=2;
-	const int NDOF2=2;
-	const int numdofs=NDOF2*numgrids;
-	int       doflist[numdofs];
-	double    pe_g[4]={0,0,0,0};
-	double    pe_g_gaussian[4]={0,0,0,0};
-	int       found=0;
-	int       dofs[1]={0};
-	double    xyz_list[numgrids][3];
-	double    z_list[numgrids];
-	double    constant_part;
-	int       numberofdofspernode;
-
-	/*gaussian points: */
-	int      num_gauss;
-	double*  segment_gauss_coord=NULL;
-	double   gauss_coord;
-	double*  gauss_weights=NULL;
-	double   gauss_weight;
-	double   gauss1[2]={1,0};
-	int      ig;
-	double   l1l2[2];
-	double   slope[2];
-	double   slope2;
-
-	double   z_g;
-	double   rho_ice,gravity,n,B;
-	double   Jdet;
-	double   ub,vb;
-	double   surface,thickness;
-	
-	bool onbed;
-	bool onsurface;
-	int  connectivity[2];
-
-	/*recover doflist: */
-	GetDofList(&doflist[0],&numberofdofspernode);
-
-	/*recover some inputs: */
-	inputs->GetParameterValue(&onbed,ElementOnBedEnum);
-	inputs->GetParameterValue(&onsurface,ElementOnSurfaceEnum);
-
-	/*recover parameters: */
-	rho_ice=matpar->GetRhoIce();
-	gravity=matpar->GetG();
-	n=matice->GetN();
-	B=matice->GetB();
-
-	//recover extra inputs
-	inputs->GetParameterValue(&slope[0],&gauss1[0],SurfaceSlopeXEnum);
-	inputs->GetParameterValue(&slope[1],&gauss1[0],SurfaceSlopeYEnum);
-	inputs->GetParameterValue(&surface,&gauss1[0],SurfaceEnum);
-	inputs->GetParameterValue(&thickness,&gauss1[0],ThicknessEnum);
-
-	connectivity[0]=nodes[0]->GetConnectivity();
-	connectivity[1]=nodes[1]->GetConnectivity();
-
-	//Get all element grid data:
-	GetVerticesCoordinates(&xyz_list[0][0], nodes, numgrids);
-	for(i=0;i<numgrids;i++)z_list[i]=xyz_list[i][2];
-	
-	//compute slope2 slopex and slopy
-	slope2=pow(slope[0],2)+pow(slope[1],2);
-
-	//%compute constant_part
-	constant_part=-2*pow(rho_ice*gravity,n)*pow(slope2,((n-1)/2));
-
-	//Get gaussian points and weights. order 2 since we have a product of 2 nodal functions
-	num_gauss=3;
-	GaussSegment(&segment_gauss_coord, &gauss_weights, num_gauss);
-
-	//Start  looping on the number of gaussian points:
-	for(ig=0;ig<num_gauss;ig++){
-
-		//Pick up the gaussian point and its weight:
-		gauss_weight=gauss_weights[ig];
-		gauss_coord=segment_gauss_coord[ig];
-
-		//compute constant_part
-		GetParameterValue(&z_g, &z_list[0],gauss_coord);
-
-		//Get Jacobian determinant:
-		GetJacobianDeterminant(&Jdet, &z_list[0],gauss_coord);
-		
-		/*Add contribution*/
-		if (onsurface){
-			for(j=0;j<NDOF2;j++){
-				pe_g_gaussian[NDOF2+j]=constant_part*pow((surface-z_g)/B,n)*slope[j]*Jdet*gauss_weight/(double)connectivity[1];
-			}
-		}
-		else{//connectivity is too large, should take only half on it
-			for(j=0;j<NDOF2;j++){
-				pe_g_gaussian[NDOF2+j]=constant_part*pow((surface-z_g)/B,n)*slope[j]*Jdet*gauss_weight*2/(double)connectivity[1];
-			}
-		}
-		
-		//add pe_gaussian vector to pe:
-		for(j=0;j<numdofs;j++){
-			pe_g[j]+=pe_g_gaussian[j];
-		}
-	} //for(ig=0;ig<num_gauss;ig++)
-
-	//Deal with lower surface
-	if (onbed){
-
-		//compute ub
-		constant_part=-1.58*pow((double)10.0,-(double)10.0)*rho_ice*gravity*thickness;
-		ub=constant_part*slope[0];
-		vb=constant_part*slope[1];
-
-		//Add to pe: 
-		pe_g[0]+=ub/(double)connectivity[0];
-		pe_g[1]+=vb/(double)connectivity[0];
-	}
-
-	/*Add pe_g to global vector pg: */
-	VecSetValues(pg,numdofs,doflist,(const double*)pe_g,ADD_VALUES);
-
-	cleanup_and_return: 
-	xfree((void**)&segment_gauss_coord);
-	xfree((void**)&gauss_weights);
-}
-/*}}}*/
-/*FUNCTION Beam::GetDofList{{{1*/
-void  Beam::GetDofList(int* doflist,int* pnumberofdofspernode){
-
-	int i,j;
-	int doflist_per_node[MAXDOFSPERNODE];
-	int numberofdofspernode;
-	
-	for(i=0;i<2;i++){
-		nodes[i]->GetDofList(&doflist_per_node[0],&numberofdofspernode);
-		for(j=0;j<numberofdofspernode;j++){
-			doflist[i*numberofdofspernode+j]=doflist_per_node[j];
-		}
-	}
-
-	/*Assign output pointers:*/
-	*pnumberofdofspernode=numberofdofspernode;
-
-}
-/*}}}*/
-/*FUNCTION Beam::GetDofList1{{{1*/
-void  Beam::GetDofList1(int* doflist){
-
-	int i;
-	for(i=0;i<2;i++){
-		doflist[i]=nodes[i]->GetDofList1();
-	}
-
-}
-/*}}}*/
-/*FUNCTION Beam::IsInput{{{1*/
-bool Beam::IsInput(int name){
-	if (name==SurfaceSlopeXEnum ||
-				name==SurfaceSlopeYEnum){
-		return true;
-	}
-	else return false;
-}
-/*}}}*/
-/*FUNCTION Beam::SetClone {{{1*/
-void  Beam::SetClone(int* minranks){
-
-	ISSMERROR("not implemented yet");
-}
-/*}}}1*/
Index: sm/trunk/src/c/objects/Elements/Beam.h
===================================================================
--- /issm/trunk/src/c/objects/Elements/Beam.h	(revision 4926)
+++ 	(revision )
@@ -1,121 +1,0 @@
-/*! \file Beam.h 
- *  \brief: header file for beam object
- */
-
-#ifndef _BEAM_H_
-#define _BEAM_H_
-
-/*Headers:*/
-/*{{{1*/
-
-#include "./Element.h"
-#include "./BeamRef.h"
-class Hook;
-class Parameters;
-class Inputs;
-class IoModel;
-class Node;
-class Matice;
-class Matpar;
-
-#include "../../shared/Exceptions/exceptions.h"
-#include "../../include/include.h"
-/*}}}*/
-
-class Beam: public Element,public BeamRef {
-
-	public:
-
-		/*ids:*/
-		int id;
-
-		Node**  nodes; //2 nodes
-		Matice* matice;
-		Matpar* matpar;
-		
-		Parameters* parameters; //pointer to solution parameters
-		Inputs* inputs;
-	
-
-		/*Beam constructors and destructor: {{{1*/
-		Beam();
-		~Beam();
-		/*}}}*/
-		/*Object virtual functions definitions: {{{1*/
-		Object* copy();
-		void    DeepEcho();
-		void    Demarshall(char** pmarshalled_dataset);
-		void    Echo();
-		int     Enum();
-		int     Id(); 
-		void    Marshall(char** pmarshalled_dataset);
-		int     MarshallSize();
-		int     MyRank();
-		/*}}}*/
-		/*Update virtual functions resolution: {{{1*/
-		void  InputUpdateFromVector(double* vector, int name, int type);
-		void  InputUpdateFromVector(int* vector, int name, int type);
-		void  InputUpdateFromVector(bool* vector, int name, int type);
-		void  InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
-		void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
-		void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
-		void  InputUpdateFromSolution(double* solution);
-		/*}}}*/
-		/*Element virtual functions definitions: {{{1*/
-		void	   ComputeBasalStress(Vec sigma_b);
-		void	   ComputePressure(Vec p_g);
-		void	   ComputeStrainRate(Vec eps);
-		void	   Configure(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
-		void	   SetCurrentConfiguration(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
-		double	CostFunction(void);
-		void	   CreateKMatrix(Mat Kgg){ISSMERROR("Not implemented yet");};
-		void	   CreatePVector(Vec pg);
-		void     DeleteResults(void);
-		void	   GetBedList(double* bed_list);
-		void*	   GetMatPar();
-		void	   GetNodes(void** nodes);
-		bool	   GetOnBed();
-		bool	   GetShelf(); 
-		void	   GetSolutionFromInputs(Vec solution);
-		void	   GetThicknessList(double* thickness_list);
-		void	   GetVectorFromInputs(Vec vector,int NameEnum);
-		void	   Gradj(Vec gradient,int control_type);
-		void	   GradjB(Vec gradient);
-		void	   GradjDrag(Vec gradient);
-		void	   InputAXPY(int YEnum, double scalar, int XEnum);
-		void	   InputControlConstrain(int control_type,double cm_min, double cm_max);
-		bool     InputConvergence(double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums);
-		void     InputDepthAverageAtBase(int enum_type,int average_enum_type){ISSMERROR("not implemented yet");}
-		void	   InputDuplicate(int original_enum,int new_enum);
-		void	   InputScale(int enum_type,double scale_factor);
-		void	   InputToResult(int enum_type,int step,double time);
-		void	   MaterialUpdateFromTemperature(void){ISSMERROR("not implemented yet");};
-		double	MassFlux(double* segment);
-		void	   MaxAbsVx(double* pmaxabsvx, bool process_units);
-		void	   MaxAbsVy(double* pmaxabsvy, bool process_units);
-		void	   MaxAbsVz(double* pmaxabsvz, bool process_units);
-		void	   MaxVel(double* pmaxvel, bool process_units);
-		void	   MaxVx(double* pmaxvx, bool process_units);
-		void	   MaxVy(double* pmaxvy, bool process_units);
-		void	   MaxVz(double* pmaxvz, bool process_units);
-		void	   MinVel(double* pminvel, bool process_units);
-		void	   MinVx(double* pminvx, bool process_units);
-		void	   MinVy(double* pminvy, bool process_units);
-		void	   MinVz(double* pminvz, bool process_units);
-		double	Misfit(void);
-		void	   PatchFill(int* pcount, Patch* patch);
-		void	   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
-		void	   ProcessResultsUnits(void);
-		double	SurfaceArea(void);
-		void     Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type);
-		void     UpdateGeometry(void){ISSMERROR("not implemented yet");};
-		/*}}}*/
-		/*Beam specific routines: {{{1*/
-		void	  CreatePVectorDiagnosticHutter(Vec pg);
-		void	  GetDofList(int* doflist,int* pnumberofdofs);
-		void	  GetDofList1(int* doflist);
-		bool	  IsInput(int name);
-		void	  SetClone(int* minranks);
-		/*}}}*/
-};
-#endif  /* _BEAM_H */
Index: /issm/trunk/src/c/objects/Elements/Penta.cpp
===================================================================
--- /issm/trunk/src/c/objects/Elements/Penta.cpp	(revision 4926)
+++ /issm/trunk/src/c/objects/Elements/Penta.cpp	(revision 4927)
@@ -5470,36 +5470,4 @@
 }
 /*}}}*/
-/*FUNCTION Penta::SpawnBeam {{{1*/
-void* Penta::SpawnBeam(int g0, int g1){
-
-	int i;
-
-	/*out of grids g0,g1 and g2 from Penta, build a beam element: */
-	Beam* beam=NULL;
-	int indices[2];
-	int zero=0;
-	Parameters *beam_parameters = NULL;
-	Inputs     *beam_inputs     = NULL;
-
-	indices[0]=g0;
-	indices[1]=g1;
-
-	beam_parameters=this->parameters;
-	beam_inputs=(Inputs*)this->inputs->SpawnBeamInputs(indices);
-
-	beam=new Beam();
-	beam->id=this->id;
-	beam->inputs=beam_inputs;
-	beam->parameters=beam_parameters;
-
-	/*now deal with ndoes,matice and matpar: */
-	beam->nodes=(Node**)xmalloc(2*sizeof(Node*));
-	for(i=0;i<2;i++)beam->nodes[i]=this->nodes[indices[i]];
-	beam->matice=this->matice;
-	beam->matpar=this->matpar;
-
-	return beam;
-}
-/*}}}*/
 /*FUNCTION Penta::SurfaceNormal {{{1*/
 void Penta::SurfaceNormal(double* surface_normal, double xyz_list[3][3]){
Index: /issm/trunk/src/c/objects/Elements/Penta.h
===================================================================
--- /issm/trunk/src/c/objects/Elements/Penta.h	(revision 4926)
+++ /issm/trunk/src/c/objects/Elements/Penta.h	(revision 4927)
@@ -173,5 +173,4 @@
 		void	  ReduceVectorStokes(double* Pe_reduced, double* Ke_temp, double* Pe_temp);
 		void	  SetClone(int* minranks);
-		void*	  SpawnBeam(int g0, int g1);
 		Tria*	  SpawnTria(int g0, int g1, int g2);
 		void	  SurfaceNormal(double* surface_normal, double xyz_list[3][3]);
Index: /issm/trunk/src/c/objects/Elements/Tria.cpp
===================================================================
--- /issm/trunk/src/c/objects/Elements/Tria.cpp	(revision 4926)
+++ /issm/trunk/src/c/objects/Elements/Tria.cpp	(revision 4927)
@@ -6065,37 +6065,4 @@
 }
 /*}}}1*/
-/*FUNCTION Tria::SpawnBeam {{{1*/
-void* Tria::SpawnBeam(int g0, int g1){
-
-	int i;
-
-	/*out of grids g0,g1 and g2 from Tria, build a beam element: */
-	Beam* beam=NULL;
-	int indices[2];
-	int zero=0;
-	Parameters *beam_parameters = NULL;
-	Inputs     *beam_inputs     = NULL;
-
-	indices[0]=g0;
-	indices[1]=g1;
-
-	beam_parameters=this->parameters;
-	beam_inputs=(Inputs*)this->inputs->SpawnBeamInputs(indices);
-
-	beam=new Beam();
-	beam->id=this->id;
-	beam->inputs=beam_inputs;
-	beam->parameters=beam_parameters;
-
-	/*now deal with nodes, matice and matpar: */
-	beam->nodes=(Node**)xmalloc(2*sizeof(Node*));
-	for(i=0;i<2;i++)beam->nodes[i]=this->nodes[indices[i]];
-	beam->matice=this->matice;
-	beam->matpar=this->matpar;
-
-
-	return beam;
-}
-/*}}}*/
 /*FUNCTION Tria::SurfaceNormal{{{1*/
 
Index: /issm/trunk/src/c/objects/Elements/Tria.h
===================================================================
--- /issm/trunk/src/c/objects/Elements/Tria.h	(revision 4926)
+++ /issm/trunk/src/c/objects/Elements/Tria.h	(revision 4927)
@@ -156,5 +156,4 @@
 		bool	  IsInput(int name);
 		void	  SetClone(int* minranks);
-		void*	  SpawnBeam(int g0, int g1);
 		void	  SurfaceNormal(double* surface_normal, double xyz_list[3][3]);
 		/*}}}*/
Index: sm/trunk/src/c/objects/Inputs/BeamVertexInput.cpp
===================================================================
--- /issm/trunk/src/c/objects/Inputs/BeamVertexInput.cpp	(revision 4926)
+++ 	(revision )
@@ -1,282 +1,0 @@
-/*!\file BeamVertexInput.c
- * \brief: implementation of the BeamVertexInput object
- */
-
-#ifdef HAVE_CONFIG_H
-	#include "config.h"
-#else
-#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
-#endif
-
-#include "stdio.h"
-#include <string.h>
-#include "../objects.h"
-#include "../../EnumDefinitions/EnumDefinitions.h"
-#include "../../shared/shared.h"
-#include "../../Container/Container.h"
-#include "../../include/include.h"
-
-/*BeamVertexInput constructors and destructor*/
-/*FUNCTION BeamVertexInput::BeamVertexInput(){{{1*/
-BeamVertexInput::BeamVertexInput(){
-	return;
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::BeamVertexInput(int in_enum_type, double* values){{{1*/
-BeamVertexInput::BeamVertexInput(int in_enum_type,double* in_values){
-
-	enum_type=in_enum_type;
-	values[0]=in_values[0];
-	values[1]=in_values[1];
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::~BeamVertexInput(){{{1*/
-BeamVertexInput::~BeamVertexInput(){
-	return;
-}
-/*}}}*/
-
-/*Object virtual functions definitions:*/
-/*FUNCTION BeamVertexInput::Echo {{{1*/
-void BeamVertexInput::Echo(void){
-	this->DeepEcho();
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::DeepEcho{{{1*/
-void BeamVertexInput::DeepEcho(void){
-
-	printf("BeamVertexInput:\n");
-	printf("   enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type));
-	printf("   values: [%g %g]\n",this->values[0],this->values[1]);
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::Id{{{1*/
-int    BeamVertexInput::Id(void){ return -1; }
-/*}}}*/
-/*FUNCTION BeamVertexInput::MyRank{{{1*/
-int    BeamVertexInput::MyRank(void){ 
-	extern int my_rank;
-	return my_rank; 
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::Marshall{{{1*/
-void  BeamVertexInput::Marshall(char** pmarshalled_dataset){
-
-	char* marshalled_dataset=NULL;
-	int   enum_value=0;
-
-	/*recover marshalled_dataset: */
-	marshalled_dataset=*pmarshalled_dataset;
-
-	/*get enum value of BeamVertexInput: */
-	enum_value=BeamVertexInputEnum;
-	
-	/*marshall enum: */
-	memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value);
-	
-	/*marshall BeamVertexInput data: */
-	memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
-	memcpy(marshalled_dataset,&values,sizeof(values));marshalled_dataset+=sizeof(values);
-
-	*pmarshalled_dataset=marshalled_dataset;
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::MarshallSize{{{1*/
-int   BeamVertexInput::MarshallSize(){
-	
-	return sizeof(values)+
-		+sizeof(enum_type)+
-		+sizeof(int); //sizeof(int) for enum_value
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::Demarshall{{{1*/
-void  BeamVertexInput::Demarshall(char** pmarshalled_dataset){
-
-	char* marshalled_dataset=NULL;
-	int   i;
-
-	/*recover marshalled_dataset: */
-	marshalled_dataset=*pmarshalled_dataset;
-
-	/*this time, no need to get enum type, the pointer directly points to the beginning of the 
-	 *object data (thanks to DataSet::Demarshall):*/
-	memcpy(&enum_type,marshalled_dataset,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
-	memcpy(&values,marshalled_dataset,sizeof(values));marshalled_dataset+=sizeof(values);
-
-	/*return: */
-	*pmarshalled_dataset=marshalled_dataset;
-	return;
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::Enum{{{1*/
-int BeamVertexInput::Enum(void){
-
-	return BeamVertexInputEnum;
-
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::copy{{{1*/
-Object* BeamVertexInput::copy() {
-	
-	return new BeamVertexInput(this->enum_type,this->values);
-
-}
-/*}}}*/
-	
-/*BeamVertexInput management*/
-/*FUNCTION BeamVertexInput::EnumType{{{1*/
-int BeamVertexInput::EnumType(void){
-
-	return this->enum_type;
-
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::SpawnBeamInput{{{1*/
-Input* BeamVertexInput::SpawnBeamInput(int* indices){
-
-	/*output*/
-	BeamVertexInput* outinput=NULL;
-
-	/*Create new Beam input (copy of current input)*/
-	outinput=new BeamVertexInput(this->enum_type,&this->values[0]);
-
-	/*Assign output*/
-	return outinput;
-
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::SpawnTriaInput{{{1*/
-Input* BeamVertexInput::SpawnTriaInput(int* indices){
-
-	ISSMERROR("Cannot spaw a Tria from a Beam");
-
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::SpawnResult{{{1*/
-ElementResult* BeamVertexInput::SpawnResult(int step, double time){
-
-	return new BeamVertexElementResult(this->enum_type,this->values,step,time);
-
-}
-/*}}}*/
-
-/*Object functions*/
-/*FUNCTION BeamVertexInput::GetParameterValue{{{1*/
-void BeamVertexInput::GetParameterValue(double* pvalue,double* gauss){
-
-	/*Call BeamRef function*/
-	BeamRef::GetParameterValue(pvalue,&values[0],*gauss);
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::GetParameterValues{{{1*/
-void BeamVertexInput::GetParameterValues(double* values,double* gauss_pointers, int numgauss){
-	/*It is assumed that output has been correctly allocated*/
-
-	int i,j;
-	double gauss[2];
-
-	for(i=0;i<numgauss;i++){
-		/*Get current Gauss point coordinates*/
-		for (j=0;j<2;j++) gauss[j]=gauss_pointers[i*2+j];
-
-		/*Assign parameter value*/
-		GetParameterValue(&values[i],&gauss[0]);
-	}
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::GetParameterDerivativeValue{{{1*/
-void BeamVertexInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, double* gauss){ISSMERROR(" not supported yet!");}
-/*}}}*/
-/*FUNCTION BeamVertexInput::ChangeEnum{{{1*/
-void BeamVertexInput::ChangeEnum(int newenumtype){
-	this->enum_type=newenumtype;
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::GetParameterAverage{{{1*/
-void BeamVertexInput::GetParameterAverage(double* pvalue){
-	*pvalue=1./2.*(values[0]+values[1]);
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::SquareMin{{{1*/
-void BeamVertexInput::SquareMin(double* psquaremin, bool process_units,Parameters* parameters){
-
-	int i;
-	const int numnodes=2;
-	double valuescopy[numnodes];
-	double squaremin;
-
-	/*First,  copy values, to process units if requested: */
-	for(i=0;i<numnodes;i++)valuescopy[i]=this->values[i];
-
-	/*Process units if requested: */
-	if(process_units)NodalValuesUnitConversion(&valuescopy[0],numnodes,enum_type,parameters);
-
-	/*Now, figure out minimum of valuescopy: */
-	squaremin=pow(valuescopy[0],2);
-	for(i=1;i<numnodes;i++){
-		if(pow(valuescopy[i],2)<squaremin)squaremin=pow(valuescopy[i],2);
-	}
-	/*Assign output pointers:*/
-	*psquaremin=squaremin;
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::Scale{{{1*/
-void BeamVertexInput::Scale(double scale_factor){
-
-	int i;
-	const int numgrids=2;
-
-	for(i=0;i<numgrids;i++)values[i]=values[i]*scale_factor;
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::AXPY{{{1*/
-void BeamVertexInput::AXPY(Input* xinput,double scalar){
-
-	int i;
-	const int numgrids=2;
-	BeamVertexInput*  xbeamvertexinput=NULL;
-
-	/*xinput is of the same type, so cast it: */
-	xbeamvertexinput=(BeamVertexInput*)xinput;
-
-	/*Carry out the AXPY operation depending on type:*/
-	switch(xinput->Enum()){
-
-		case BeamVertexInputEnum:
-			for(i=0;i<numgrids;i++)this->values[i]=this->values[i]+scalar*xbeamvertexinput->values[i];
-			return;
-
-		default:
-			ISSMERROR("not implemented yet");
-	}
-
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::Constrain{{{1*/
-void BeamVertexInput::Constrain(double cm_min, double cm_max){
-
-	int i;
-	const int numgrids=2;
-		
-	if(!isnan(cm_min)) for(i=0;i<numgrids;i++)if (this->values[i]<cm_min)this->values[i]=cm_min;
-	if(!isnan(cm_max)) for(i=0;i<numgrids;i++)if (this->values[i]>cm_max)this->values[i]=cm_max;
-
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::GetVectorFromInputs{{{1*/
-void BeamVertexInput::GetVectorFromInputs(Vec vector,int* doflist){
-
-	const int numvertices=2;
-	VecSetValues(vector,numvertices,doflist,(const double*)this->values,ADD_VALUES);
-
-
-}
-/*}}}*/
-/*FUNCTION BeamVertexInput::GetValuesPtr{{{1*/
-void BeamVertexInput::GetValuesPtr(double** pvalues,int* pnum_values){
-
-	*pvalues=this->values;
-	*pnum_values=2;
-
-}
-/*}}}*/
Index: sm/trunk/src/c/objects/Inputs/BeamVertexInput.h
===================================================================
--- /issm/trunk/src/c/objects/Inputs/BeamVertexInput.h	(revision 4926)
+++ 	(revision )
@@ -1,73 +1,0 @@
-/*! \file BeamVertexInput.h 
- *  \brief: header file for triavertexinput object
- */
-
-
-#ifndef _BEAMVERTEXINPUT_H_
-#define _BEAMVERTEXINPUT_H_
-
-/*Headers:*/
-/*{{{1*/
-#include "./Input.h"
-#include "../Elements/BeamRef.h"
-/*}}}*/
-
-
-class BeamVertexInput: public Input,public BeamRef{
-
-	public:
-		/*just hold 2 values for 2 vertices: */
-		int    enum_type;
-		double values[2];
-
-		/*BeamVertexInput constructors, destructors: {{{1*/
-		BeamVertexInput();
-		BeamVertexInput(int enum_type,double* values);
-		~BeamVertexInput();
-		/*}}}*/
-		/*Object virtual functions definitions:{{{1 */
-		void  Echo();
-		void  DeepEcho();
-		int   Id(); 
-		int   MyRank();
-		void  Marshall(char** pmarshalled_dataset);
-		int   MarshallSize();
-		void  Demarshall(char** pmarshalled_dataset);
-		int   Enum();
-		Object* copy();
-		/*}}}*/
-		/*BeamVertexInput management: {{{1*/
-		int   EnumType();
-		Input* SpawnBeamInput(int* indices);
-		Input* SpawnTriaInput(int* indices);
-		Input* PointwiseDivide(Input* inputB){ISSMERROR("not implemented yet");};
-		ElementResult* SpawnResult(int step, double time);
-		/*}}}*/
-		/*numerics: {{{1*/
-		void GetParameterValue(bool* pvalue){ISSMERROR("not implemented yet");};
-		void GetParameterValue(int* pvalue){ISSMERROR("not implemented yet");};
-		void GetParameterValue(double* pvalue){ISSMERROR("not implemented yet");};
-		void GetParameterValue(double* pvalue,double* gauss);
-		void GetParameterValues(double* values,double* gauss_pointers, int numgauss);
-		void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, double* gauss);
-		void GetParameterAverage(double* pvalue);
-		void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, double* gauss){ISSMERROR("not implemented yet");};
-		void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, double* gauss){ISSMERROR("not implemented yet");};
-		void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, double* gauss){ISSMERROR("not implemented yet");};
-		void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, double* gauss){ISSMERROR("not implemented yet");};
-		void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, double* gauss){ISSMERROR("not implemented yet");};
-		void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, double* gauss){ISSMERROR("not implemented yet");};
-		void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, double* gauss){ISSMERROR("not implemented yet");};
-		void ChangeEnum(int newenumtype);
-		void SquareMin(double* psquaremin, bool process_units,Parameters* parameters);
-		void Scale(double scale_factor);
-		void AXPY(Input* xinput,double scalar);
-		void Constrain(double cm_min, double cm_max);
-		void Extrude(void){ISSMERROR("not supported yet");};
-		void VerticallyIntegrate(Input* thickness_input){ISSMERROR("not supported yet");};
-		void GetVectorFromInputs(Vec vector,int* doflist);
-		void GetValuesPtr(double** pvalues,int* pnum_values);
-		/*}}}*/
-
-};
-#endif  /* _BEAMVERTEXINPUT_H */
Index: /issm/trunk/src/c/objects/Inputs/BoolInput.cpp
===================================================================
--- /issm/trunk/src/c/objects/Inputs/BoolInput.cpp	(revision 4926)
+++ /issm/trunk/src/c/objects/Inputs/BoolInput.cpp	(revision 4927)
@@ -131,19 +131,4 @@
 }
 /*}}}*/
-/*FUNCTION BoolInput::SpawnBeamInput{{{1*/
-Input* BoolInput::SpawnBeamInput(int* indices){
-
-	/*output*/
-	BoolInput* outinput=new BoolInput();
-
-	/*only copy current value*/
-	outinput->enum_type=this->enum_type;
-	outinput->value=this->value;
-
-	/*Assign output*/
-	return outinput;
-
-}
-/*}}}*/
 /*FUNCTION BoolInput::SpawnTriaInput{{{1*/
 Input* BoolInput::SpawnTriaInput(int* indices){
Index: /issm/trunk/src/c/objects/Inputs/BoolInput.h
===================================================================
--- /issm/trunk/src/c/objects/Inputs/BoolInput.h	(revision 4926)
+++ /issm/trunk/src/c/objects/Inputs/BoolInput.h	(revision 4927)
@@ -38,5 +38,4 @@
 		/*BoolInput management: {{{1*/
 		int   EnumType();
-		Input* SpawnBeamInput(int* indices);
 		Input* SpawnTriaInput(int* indices);
 		Input* PointwiseDivide(Input* inputB){ISSMERROR("not implemented yet");};
Index: /issm/trunk/src/c/objects/Inputs/DoubleInput.cpp
===================================================================
--- /issm/trunk/src/c/objects/Inputs/DoubleInput.cpp	(revision 4926)
+++ /issm/trunk/src/c/objects/Inputs/DoubleInput.cpp	(revision 4927)
@@ -131,19 +131,4 @@
 }
 /*}}}*/
-/*FUNCTION DoubleInput::SpawnBeamInput{{{1*/
-Input* DoubleInput::SpawnBeamInput(int* indices){
-
-	/*output*/
-	DoubleInput* outinput=new DoubleInput();
-
-	/*only copy current value*/
-	outinput->enum_type=this->enum_type;
-	outinput->value=this->value;
-
-	/*Assign output*/
-	return outinput;
-
-}
-/*}}}*/
 /*FUNCTION DoubleInput::SpawnTriaInput{{{1*/
 Input* DoubleInput::SpawnTriaInput(int* indices){
Index: /issm/trunk/src/c/objects/Inputs/DoubleInput.h
===================================================================
--- /issm/trunk/src/c/objects/Inputs/DoubleInput.h	(revision 4926)
+++ /issm/trunk/src/c/objects/Inputs/DoubleInput.h	(revision 4927)
@@ -37,5 +37,4 @@
 		/*DoubleInput management: {{{1*/
 		int   EnumType();
-		Input* SpawnBeamInput(int* indices);
 		Input* SpawnTriaInput(int* indices);
 		Input* PointwiseDivide(Input* inputB){ISSMERROR("not implemented yet");};
Index: /issm/trunk/src/c/objects/Inputs/Input.h
===================================================================
--- /issm/trunk/src/c/objects/Inputs/Input.h	(revision 4926)
+++ /issm/trunk/src/c/objects/Inputs/Input.h	(revision 4927)
@@ -37,5 +37,4 @@
 		virtual void ChangeEnum(int newenumtype)=0;
 		
-		virtual Input* SpawnBeamInput(int* indices)=0;
 		virtual Input* SpawnTriaInput(int* indices)=0;
 		virtual Input* PointwiseDivide(Input* inputB)=0;
Index: /issm/trunk/src/c/objects/Inputs/IntInput.cpp
===================================================================
--- /issm/trunk/src/c/objects/Inputs/IntInput.cpp	(revision 4926)
+++ /issm/trunk/src/c/objects/Inputs/IntInput.cpp	(revision 4927)
@@ -131,18 +131,4 @@
 }
 /*}}}*/
-/*FUNCTION IntInput::SpawnBeamInput{{{1*/
-Input* IntInput::SpawnBeamInput(int* indices){
-
-	/*output*/
-	IntInput* outinput=new IntInput();
-
-	/*only copy current value*/
-	outinput->enum_type=this->enum_type;
-	outinput->value=this->value;
-
-	/*Assign output*/
-	return outinput;
-}
-/*}}}*/
 /*FUNCTION IntInput::SpawnTriaInput{{{1*/
 Input* IntInput::SpawnTriaInput(int* indices){
Index: /issm/trunk/src/c/objects/Inputs/IntInput.h
===================================================================
--- /issm/trunk/src/c/objects/Inputs/IntInput.h	(revision 4926)
+++ /issm/trunk/src/c/objects/Inputs/IntInput.h	(revision 4927)
@@ -38,5 +38,4 @@
 		/*IntInput management: {{{1*/
 		int   EnumType();
-		Input* SpawnBeamInput(int* indices);
 		Input* SpawnTriaInput(int* indices);
 		Input* PointwiseDivide(Input* inputB){ISSMERROR("not implemented yet");};
Index: /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp
===================================================================
--- /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp	(revision 4926)
+++ /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp	(revision 4927)
@@ -142,29 +142,4 @@
 }
 /*}}}*/
-/*FUNCTION PentaVertexInput::SpawnBeamInput{{{1*/
-Input* PentaVertexInput::SpawnBeamInput(int* indices){
-
-	/*output*/
-	BeamVertexInput* outinput=NULL;
-	double newvalues[2];
-
-	/*Loop over the new indices*/
-	for(int i=0;i<2;i++){
-
-		/*Check index value*/
-		ISSMASSERT(indices[i]>=0 && indices[i]<6);
-
-		/*Assign value to new input*/
-		newvalues[i]=this->values[indices[i]];
-	}
-
-	/*Create new Beam input*/
-	outinput=new BeamVertexInput(this->enum_type,&newvalues[0]);
-
-	/*Assign output*/
-	return outinput;
-
-}
-/*}}}*/
 /*FUNCTION PentaVertexInput::SpawnTriaInput{{{1*/
 Input* PentaVertexInput::SpawnTriaInput(int* indices){
Index: /issm/trunk/src/c/objects/Inputs/PentaVertexInput.h
===================================================================
--- /issm/trunk/src/c/objects/Inputs/PentaVertexInput.h	(revision 4926)
+++ /issm/trunk/src/c/objects/Inputs/PentaVertexInput.h	(revision 4927)
@@ -38,5 +38,4 @@
 		/*PentaVertexInput management: {{{1*/
 		int   EnumType();
-		Input* SpawnBeamInput(int* indices);
 		Input* SpawnTriaInput(int* indices);
 		Input* PointwiseDivide(Input* inputB);
Index: /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp
===================================================================
--- /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp	(revision 4926)
+++ /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp	(revision 4927)
@@ -142,29 +142,4 @@
 }
 /*}}}*/
-/*FUNCTION TriaVertexInput::SpawnBeamInput{{{1*/
-Input* TriaVertexInput::SpawnBeamInput(int* indices){
-
-	/*output*/
-	BeamVertexInput* outinput=NULL;
-	double newvalues[2];
-
-	/*Loop over the new indices*/
-	for(int i=0;i<2;i++){
-
-		/*Check index value*/
-		ISSMASSERT(indices[i]>=0 && indices[i]<3);
-
-		/*Assign value to new input*/
-		newvalues[i]=this->values[indices[i]];
-	}
-
-	/*Create new Beam input*/
-	outinput=new BeamVertexInput(this->enum_type,&newvalues[0]);
-
-	/*Assign output*/
-	return outinput;
-
-}
-/*}}}*/
 /*FUNCTION TriaVertexInput::SpawnTriaInput{{{1*/
 Input* TriaVertexInput::SpawnTriaInput(int* indices){
Index: /issm/trunk/src/c/objects/Inputs/TriaVertexInput.h
===================================================================
--- /issm/trunk/src/c/objects/Inputs/TriaVertexInput.h	(revision 4926)
+++ /issm/trunk/src/c/objects/Inputs/TriaVertexInput.h	(revision 4927)
@@ -38,5 +38,4 @@
 		/*TriaVertexInput management: {{{1*/
 		int   EnumType();
-		Input* SpawnBeamInput(int* indices);
 		Input* SpawnTriaInput(int* indices);
 		Input* PointwiseDivide(Input* inputB){ISSMERROR("not implemented yet");};
Index: /issm/trunk/src/c/objects/objects.h
===================================================================
--- /issm/trunk/src/c/objects/objects.h	(revision 4926)
+++ /issm/trunk/src/c/objects/objects.h	(revision 4927)
@@ -33,5 +33,4 @@
 
 /*Elements: */
-#include "./Elements/Beam.h"
 #include "./Elements/BeamRef.h"
 #include "./Elements/Element.h"
@@ -48,5 +47,4 @@
 #include "./Inputs/DoubleInput.h"
 #include "./Inputs/IntInput.h"
-#include "./Inputs/BeamVertexInput.h"
 #include "./Inputs/PentaVertexInput.h"
 #include "./Inputs/TriaVertexInput.h"
@@ -57,5 +55,4 @@
 #include "./ElementResults/TriaVertexElementResult.h"
 #include "./ElementResults/PentaVertexElementResult.h"
-#include "./ElementResults/BeamVertexElementResult.h"
 
 /*ExternalResults: */