diff --git a/Code/C/fem/constraint.c b/Code/C/fem/constraint.c
new file mode 100644
index 0000000..8316f56
--- /dev/null
+++ b/Code/C/fem/constraint.c
@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include "constraint.h"
+
+void constraintPrint(Constraint *theConstraint){
+  printf("Constraint No. : %d \n", theConstraint->tag);
+  printf("Node No. : %d \n", theConstraint->NodeTag);
+  printf("Constraint: %d %d %d \n", theConstraint->DOF[0], theConstraint->DOF[1], theConstraint->DOF[2]);
+}
+
+void constraintSetup(Constraint *theConstraint, int tag, int NodeTag, int DOF1, int DOF2, int DOF3) {
+  theConstraint->tag = tag;
+  theConstraint->NodeTag = NodeTag;
+  theConstraint->DOF[0] = DOF1;
+  theConstraint->DOF[1] = DOF2;
+  theConstraint->DOF[2] = DOF3;
+  theConstraint->next = NULL;
+}
diff --git a/Code/C/fem/constraint.h b/Code/C/fem/constraint.h
new file mode 100644
index 0000000..c5258ba
--- /dev/null
+++ b/Code/C/fem/constraint.h
@@ -0,0 +1,17 @@
+#ifndef _CONSTRAINT  //if no definition for "_CONSTRAINT"
+#define _CONSTRAINT
+//preventing the compiler from loading it again if multiple reference to this file exists.
+
+#include <stdio.h>
+
+typedef struct constraint {
+  int tag;
+  int NodeTag;
+  int DOF[3];
+  struct constraint *next;
+} Constraint;
+
+void constraintPrint(Constraint *);
+void constraintSetup(Constraint *, int tag, int NodeTag, int DOF1, int DOF2, int DOF3);
+
+#endif
diff --git a/Code/C/fem/domain.c b/Code/C/fem/domain.c
index ffb8052..e2770bd 100644
--- a/Code/C/fem/domain.c
+++ b/Code/C/fem/domain.c
@@ -6,6 +6,7 @@
 void domainPrint(Domain *theDomain) {
   printf("The Nodes:\n");
   domainPrintNodes(theDomain);
+  domainPrintConstraint(theDomain);
 }
 
 void domainAddNode(Domain *theDomain, int tag, double crd1, double crd2) {
@@ -17,6 +18,7 @@ void domainAddNode(Domain *theDomain, int tag, double crd1, double crd2) {
   } else {
     theNextNode->next = NULL;
   }
+
   theDomain->theNodes = theNextNode;
 }
 
@@ -32,10 +34,45 @@ Node *domainGetNode(Domain *theDomain, int nodeTag) {
   Node *theCurrentNode = theDomain->theNodes;
   while (theCurrentNode != NULL) {
     if (theCurrentNode->tag == nodeTag) {
-      return theCurrentNode;
+      return theCurrentNode; //return gets out of the program
     } else {
       theCurrentNode = theCurrentNode->next;
     }
   };
   return NULL;
 }
+
+
+void domainAddConstraint(Domain *theDomain, int tag, int NodeTag, int DOF1, int DOF2, int DOF3) {
+  Constraint *theNextConstraint = (Constraint *)malloc(sizeof(Constraint));
+  constraintSetup(theNextConstraint, tag, NodeTag, DOF1, DOF2, DOF3);
+
+  if (theDomain->theConstraints != NULL) {
+    	theNextConstraint->next = theDomain->theConstraints;
+	
+  } else {
+  	theNextConstraint->next = NULL;
+  }
+
+  theDomain->theConstraints = theNextConstraint;
+}
+
+void domainPrintConstraint(Domain *theDomain) {
+  Constraint *theCurrentConstraint = theDomain->theConstraints;
+  while (theCurrentConstraint != NULL) {
+    constraintPrint(theCurrentConstraint);
+    theCurrentConstraint = theCurrentConstraint->next;
+  };
+}
+
+Constraint *domainGetConstraint(Domain *theDomain, int constraintTag) {
+  Constraint *theCurrentConstraint = theDomain->theConstraints;
+  while (theCurrentConstraint != NULL) {
+    if (theCurrentConstraint->tag == constraintTag) {
+      return theCurrentConstraint; //return gets out of the program
+    } else {
+      theCurrentConstraint = theCurrentConstraint->next;
+    }
+  };
+  return NULL;
+}
diff --git a/Code/C/fem/domain.h b/Code/C/fem/domain.h
index 29151ec..1d70de7 100644
--- a/Code/C/fem/domain.h
+++ b/Code/C/fem/domain.h
@@ -1,11 +1,19 @@
 #include "node.h"
+#include "constraint.h"
 
 typedef struct struct_domain {
   Node *theNodes;
+  Constraint *theConstraints;
+
 } Domain;
 
 void domainPrint(Domain *theDomain);
+
 void domainAddNode(Domain *theDomain, int tag, double crd1, double crd2);
 void domainPrintNodes(Domain *theDomain);
 Node *domainGetNode(Domain *, int nodeTag);
 
+void domainAddConstraint(Domain *theDomain, int tag, int NodeTag, int DOF1, int DOF2, int DOF3);
+void domainPrintConstraint(Domain *theDomain);
+Constraint *domainGetConstraint(Domain *, int constaintTag);
+
diff --git a/Code/C/fem/domain1.c b/Code/C/fem/domain1.c
new file mode 100644
index 0000000..bc2f75a
--- /dev/null
+++ b/Code/C/fem/domain1.c
@@ -0,0 +1,79 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "domain.h"
+#include "node.h"
+
+void domainPrint(Domain *theDomain) {
+  printf("The Nodes:\n");
+  domainPrintNodes(theDomain);
+  domainPrintConstraint(theDomain);
+}
+
+void domainAddNode(Domain *theDomain, int tag, double crd1, double crd2) {
+  Node *theNextNode = (Node *)malloc(sizeof(Node));
+  nodeSetup(theNextNode, tag, crd1, crd2);
+
+  if (theDomain->theNodes != NULL) {
+    	theNextNode->next = theDomain->theNodes;
+	
+  } else {
+  	theNextNode->next = NULL;
+  }
+
+  theDomain->theNodes = theNextNode;
+}
+
+void domainPrintNodes(Domain *theDomain) {
+  Node *theCurrentNode = theDomain->theNodes;
+  while (theCurrentNode != NULL) {
+    nodePrint(theCurrentNode);
+    theCurrentNode = theCurrentNode->next;
+  };
+}
+
+Node *domainGetNode(Domain *theDomain, int nodeTag) {
+  Node *theCurrentNode = theDomain->theNodes;
+  while (theCurrentNode != NULL) {
+    if (theCurrentNode->tag == nodeTag) {
+      return theCurrentNode; //return gets out of the program
+    } else {
+      theCurrentNode = theCurrentNode->next;
+    }
+  };
+  return NULL;
+}
+
+
+void domainAddConstraint(Domain *theDomain, int tag, int NodeTag, int DOF1, int DOF2, int DOF3) {
+  Constraint *theNextConstraint = (Constraint *)malloc(sizeof(Constraint));
+  constraintSetup(theNextConstraint, tag, NodeTag, DOF1, DOF2, DOF3);
+
+  if (theDomain->theConstraints != NULL) {
+    	theNextConstraint->next = theDomain->theConstraints;
+	
+  } else {
+  	theNextConstraint->next = NULL;
+  }
+
+  theDomain->theConstraints = theNextConstraint;
+}
+
+void domainPrintConstraint(Domain *theDomain) {
+  Constraint *theCurrentConstraint = theDomain->theConstraints;
+  while (theCurrentConstraint != NULL) {
+    constraintPrint(theCurrentConstraint);
+    theCurrentConstraint = theCurrentConstraint->next;
+  };
+}
+
+Constraint *domainGetConstraint(Domain *theDomain, int constraintTag) {
+  Constraint *theCurrentConstraint = theDomain->theConstraints;
+  while (theCurrentConstraint != NULL) {
+    if (theCurrentConstraint->tag == constraintTag) {
+      return theCurrentConstraint; //return gets out of the program
+    } else {
+      theCurrentConstraint = theCurrentConstraint->next;
+    }
+  };
+  return NULL;
+}
diff --git a/Code/C/fem/domain1.h b/Code/C/fem/domain1.h
new file mode 100644
index 0000000..1d70de7
--- /dev/null
+++ b/Code/C/fem/domain1.h
@@ -0,0 +1,19 @@
+#include "node.h"
+#include "constraint.h"
+
+typedef struct struct_domain {
+  Node *theNodes;
+  Constraint *theConstraints;
+
+} Domain;
+
+void domainPrint(Domain *theDomain);
+
+void domainAddNode(Domain *theDomain, int tag, double crd1, double crd2);
+void domainPrintNodes(Domain *theDomain);
+Node *domainGetNode(Domain *, int nodeTag);
+
+void domainAddConstraint(Domain *theDomain, int tag, int NodeTag, int DOF1, int DOF2, int DOF3);
+void domainPrintConstraint(Domain *theDomain);
+Constraint *domainGetConstraint(Domain *, int constaintTag);
+
diff --git a/Code/C/fem/main.c b/Code/C/fem/main.c
index 6242353..9a3a7c8 100644
--- a/Code/C/fem/main.c
+++ b/Code/C/fem/main.c
@@ -1,17 +1,29 @@
 #include "node.h"
 #include "domain.h"
+#include "constraint.h"
 
 int main(int argc, char **argv) {
   Domain theDomain;
+
   theDomain.theNodes=0;
+
   domainAddNode(&theDomain, 1, 0.0, 0.0);
   domainAddNode(&theDomain, 2, 0.0, 2.0);
   domainAddNode(&theDomain, 3, 1.0, 1.0);
   
+  theDomain.theConstraints = 0;
+  domainAddConstraint(&theDomain, 1, 1, 1,1,1);
+  domainAddConstraint(&theDomain, 2, 3, 1,0,0);
+  
   domainPrint(&theDomain);
 
   // get and print singular node
   printf("\nsingular node:\n");
   Node *theNode = domainGetNode(&theDomain, 2);
   nodePrint(theNode);
+
+  // get and print constraints
+  printf("\nconstraints:\n");
+  Constraint *theConstraint = domainGetConstraint(&theDomain, 1);
+  constraintPrint(theConstraint);
 }
diff --git a/Code/C/fem/main1.c b/Code/C/fem/main1.c
new file mode 100644
index 0000000..ab0664d
--- /dev/null
+++ b/Code/C/fem/main1.c
@@ -0,0 +1,28 @@
+#include "node.h"
+#include "domain.h"
+#include "constraint.h"
+
+int main(int argc, char **argv) {
+  Domain theDomain;
+
+  theDomain.theNodes = 0;  //initialize the pointers
+  domainAddNode(&theDomain, 1, 0.0, 0.0);
+  domainAddNode(&theDomain, 2, 0.0, 2.0);
+  domainAddNode(&theDomain, 3, 1.0, 1.0);
+  
+  theDomain.theConstraints = 0;
+  domainAddConstraint(&theDomain, 1, 1, 1,1,1);
+  domainAddConstraint(&theDomain, 2, 3, 1,0,0);
+  
+  domainPrint(&theDomain);
+
+  // get and print singular node
+  printf("\nsingular node:\n");
+  Node *theNode = domainGetNode(&theDomain, 2);
+  nodePrint(theNode);
+
+  // get and print constraints
+  printf("\nconstraints:\n");
+  Constraint *theConstraint = domainGetConstraint(&theDomain, 1);
+  constraintPrint(theConstraint);
+}
diff --git a/Code/Parallel/mpi/pi_numeric_integration_parallel.cpp b/Code/Parallel/mpi/pi_numeric_integration_parallel.cpp
new file mode 100644
index 0000000..a78040d
--- /dev/null
+++ b/Code/Parallel/mpi/pi_numeric_integration_parallel.cpp
@@ -0,0 +1,43 @@
+#include <mpi.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <ctime>
+#include <cstdio>
+#define LUMP 5
+
+using namespace std;
+
+static int long numSteps=100000;
+
+int main(int argc, char **argv) {
+
+	int numP, procID;
+
+	double pi=0, time=0;
+
+	clock_t start; //timer
+	start = std::clock();
+	//cout<<start<<endl;
+
+  	// the usual mpi initialization
+  	MPI_Init(&argc, &argv);
+  	MPI_Comm_size(MPI_COMM_WORLD, &numP);
+  	MPI_Comm_rank(MPI_COMM_WORLD, &procID);
+	
+	
+	
+
+	
+	//integration
+	for (int aa=0; aa<numSteps; aa++) {
+		double x= (float)aa*1.0/(float)numSteps;
+		pi=pi+4.0/(1.0+x*x)*1.0/(float)numSteps;
+	}
+
+	cout<<pi<<endl;
+	//timer
+	time=( std::clock() - start ) / (double) CLOCKS_PER_SEC;
+	cout<<time<<endl;
+	return 0;
+}
diff --git a/Code/Parallel/mpi/submit.sh b/Code/Parallel/mpi/submit.sh
index 9a3b0ec..9666c47 100644
--- a/Code/Parallel/mpi/submit.sh
+++ b/Code/Parallel/mpi/submit.sh
@@ -6,9 +6,9 @@
 # This script requests 1 node and 8 cores/node (out of total 64 avail)
 # for a total of 8 MPI tasks.
 #---------------------------------------------------------------------
-#SBATCH -J myjob          # Job name
-#SBATCH -o myjob.%j.out   # stdout; %j expands to jobid
-#SBATCH -e myjob.%j.err   # stderr; skip to combine stdout and stderr
+#SBATCH -J jiawei          # Job name
+#SBATCH -o jiawei.%j.out   # stdout; %j expands to jobid
+#SBATCH -e jiawei.%j.err   # stderr; skip to combine stdout and stderr
 #SBATCH -p development    # queue
 #SBATCH -N 1              # Number of nodes, not cores (64 cores/node)
 #SBATCH -n 8              # Total number of MPI tasks (if omitted, n=N)
@@ -17,4 +17,4 @@
 module petsc    # load any needed modules, these just examples
 moduele load list
 
-ibrun ./a.out
\ No newline at end of file
+ibrun ./a.out
diff --git a/Code/Parallel/openmp/pi_numeric_integration_parallel_opM1.cpp b/Code/Parallel/openmp/pi_numeric_integration_parallel_opM1.cpp
new file mode 100644
index 0000000..2d7eee4
--- /dev/null
+++ b/Code/Parallel/openmp/pi_numeric_integration_parallel_opM1.cpp
@@ -0,0 +1,55 @@
+#include <omp.h>
+#include <stdio.h>
+#include <stdlib.h>
+//#include <iostream>
+#include <ctime>
+#include <cstdio>
+
+using namespace std;
+
+static int long numSteps=100000;
+
+int main(int argc, char **argv) {
+
+	int numP, procID;
+
+	double pi=0, time1, time2;
+	
+	//clock_t start; //timer
+	time1 = omp_get_wtime();
+	//start = std::clock();
+	//cout<<start<<endl;
+	double stepSize=1.0/(float)numSteps;
+	
+	#pragma omp parallel (+:pi) //A synchronization feature
+	{
+		int tid = omp_get_thread_num();
+	 	int numT = omp_get_num_threads();
+		cout<<numT<<endl;
+		double sum=0.;	
+
+		//integration
+		double aveNumStep=numSteps/numT;
+		if (tid<numT-1) {
+			for (int aa=aveNumStep*(tid-1); aa<aveNumStep*tid; aa++) {
+				double x= (float)aa*stepSize;
+				sum+=4.0/(1.0+x*x)*stepSize;
+			}
+			pi=pi+sum; // pi is outside paralle process. Don't get it into the for-loop!
+			
+		} else { //the last thread gets a little more
+			for (int aa=aveNumStep*(tid-1); aa<numSteps; aa++) {
+				double x= (float)aa*stepSize;
+				sum+=4.0/(1.0+x*x)*stepSize;
+			}
+			pi=pi+sum; // pi is outside paralle process. Don't get it into the for-loop!
+		}
+	}
+	//cout<<pi<<endl;
+	
+	//timer
+	time2=omp_get_wtime();
+	//cout<<time2-time1<<endl;
+	printf("Synchronization: PI = %16.14f in %.4g sec\n",pi, time2-time1)
+	return 0;
+}
diff --git a/Code/Parallel/openmp/pi_numeric_integration_parallel_opM2.c b/Code/Parallel/openmp/pi_numeric_integration_parallel_opM2.c
new file mode 100644
index 0000000..bbdb18b
--- /dev/null
+++ b/Code/Parallel/openmp/pi_numeric_integration_parallel_opM2.c
@@ -0,0 +1,67 @@
+#include <omp.h>
+#include <stdio.h>
+//#include <stdlib.h>
+//#include <iostream>
+//#include <ctime>
+#include <time.h>
+//#include <cstdio>
+
+//using namespace std;
+
+static int long numSteps=1000000000;
+
+int main(int argc, char **argv) {
+
+	int numP, procID;
+
+	double pi=0, time1, time2;
+	
+	//clock_t start; //timer
+	time1 = omp_get_wtime();
+	//start = std::clock();
+	//cout<<start<<endl;
+	double stepSize=1.0/(float)numSteps;
+	
+	#pragma omp parallel  //A synchronization feature
+	{
+		//int tid = omp_get_thread_num();
+	 	//int numT = omp_get_num_threads();
+		//cout<<numT<<endl;
+		double sum=0.;	
+
+		//integration
+		//double aveNumStep=numSteps/numT;
+		//if (tid<numT-1) {
+//#pragma omp for
+//			for (int aa=aveNumStep*(tid-1); aa<aveNumStep*tid; aa++) {
+//				double x= (float)aa*stepSize;
+//				sum+=4.0/(1.0+x*x)*stepSize;
+//			}
+//#pragma omp critical
+//			pi=pi+sum; // pi is outside paralle process. Don't get it into the for-loop!
+			
+//		} else { //the last thread gets a little more
+//#pragma omp for
+//			for (int aa=aveNumStep*(tid-1); aa<numSteps; aa++) {
+//				double x= (float)aa*stepSize;
+//				sum+=4.0/(1.0+x*x)*stepSize;
+//			}
+//#pragma omp critical
+//			pi=pi+sum; // pi is outside paralle process. Don't get it into the for-loop!
+//		}
+		#pragma omp for
+		for (int aa=0; aa<numSteps; aa++) {
+			double x= (float)aa*stepSize;
+			sum+=4.0/(1.0+x*x)*stepSize;
+		}
+		#pragma omp critical
+		pi=pi+sum; // pi is outside paralle process. Don't get it into the for-loop!
+	}
+	//cout<<pi<<endl;
+	
+	//timer
+	time2=omp_get_wtime();
+	//cout<<time2-time1<<endl;
+	printf("Synchronization: PI = %16.14f in %.4g sec\n",pi, time2-time1);
+	return 0;
+}
diff --git a/Code/Parallel/openmp/submit.sh b/Code/Parallel/openmp/submit.sh
index 16e13b3..8c99e38 100644
--- a/Code/Parallel/openmp/submit.sh
+++ b/Code/Parallel/openmp/submit.sh
@@ -10,7 +10,7 @@
 #SBATCH -p normal           # Submit to the 'normal' or 'development' queue
 #SBATCH -N 1                # Total number of nodes requested (16 cores/node)
 #SBATCH -n 1                # Total number of mpi tasks requested
-#SBATCH -t 01:30:00         # Run time (hh:mm:ss) - 1.5 hours
+#SBATCH -t 00:00:10         # Run time (hh:mm:ss) - 1.5 hours
 # The next line is required if the user has more than one project
 # #SBATCH -A A-yourproject  # Allocation name to charge job against
 
@@ -20,5 +20,5 @@
 export OMP_NUM_THREADS=16
 
 # Run the OpenMP application
-./main.exe
+./a.out
 
diff --git a/pi_numeric_integration.cpp b/pi_numeric_integration.cpp
new file mode 100644
index 0000000..49959f4
--- /dev/null
+++ b/pi_numeric_integration.cpp
@@ -0,0 +1,29 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <ctime>
+#include <cstdio>
+
+using namespace std;
+
+
+static int long numSteps=100000;
+int main() {
+	double pi=0, time=0;
+
+	clock_t start; //timer
+	start = std::clock();
+	//cout<<start<<endl;
+	//integration
+	for (int aa=0; aa<numSteps; aa++) {
+		double x= (float)aa*1.0/(float)numSteps;
+		pi=pi+4.0/(1.0+x*x)*1.0/(float)numSteps;
+	}
+
+	cout<<pi<<endl;
+	//timer
+	time=( std::clock() - start ) / (double) CLOCKS_PER_SEC;
+	cout<<time<<endl;
+	return 0;
+}