#Supplementary Material (ESI) for Lab on a Chip
#This journal is © The Royal Society of Chemistry 2010
#include <iostream>
#include <vector>
#include <algorithm> // sort, max_element, random_shuffle, remove_if, lower_bound 
#include <functional> // greater, bind2nd
using namespace std;
#include  <string>
#include  <malloc.h>
#include  <stdlib.h>
#include  <stdio.h>
#include  <string.h>
#include  <math.h>
#include  "TECIO.h"
#include  <mpi.h>
#include <time.h> 
#include <sys/types.h>
#ifdef _MSC_VER // Windows
#include  <io.h>
#include <direct.h>
#include <process.h>
#else // Linux
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#endif /*_MSC_VER*/
extern  FILE *rf=stdin, *rdev=stdin, *rdev2=stdin,*f=stdout, *wdev=stdout, *f2=stdout, *adev=stdout, *wbdev=stdout,*rbdev=stdin, *f3=stdout, *abdev=stdout;
#include  "nrutil.h"
#include  "nrutil.c"
#include  "myvector.h"
#include  "myMatrixSolver.h"
#include  "geometry.h"
/*------------------- Global Variable -----------------------------------------*/
int                *CPIT_,*subcset_;
int                *boundCell2_;
int                *CELL;
double                *CellRT_;   /* calculate the residence time (RT) of visited cell at the ith cell, will be reset   */
double             *vertex_;
double             *cellcenter_;
int                *BetaCell_;
int                *cbound_, *cbound0_;
double     *verU_;
double     *verV_;
double     *verW_;
double     *verT_;
double     *cellU_;
double     *cellV_;
double     *cellW_;
double     *cellT_;
int        *Deposit_;
int        *VcCount_, *VbCount_;
int        *VToC_;
unsigned int *VToC0_,*Vbound0_; 
int        *Length_cell_,*cell0_;
int        *Vbound_;
  std::vector<int> Bicp_(0);
  std::vector<int> Bface_(0);
  std::vector<int> Bregion_(0);
  std::vector<int> Bound_(0);
  std::vector<unsigned int> Bound0_(0);
  std::vector<int> Bound_Length_(0);

  std::vector<int> cell_(0);
double   *tetra_xyz_;
double   *tetra_uvw_,*tetra_t_;
double   *w;

int                bbcount,cccount;

double           X_ref, Y_ref, Z_ref;
double           X_min, Y_min, Z_min;
double           Sum_slope;
double           Vel_max;
typetrack          TR[MXTR+1];
double             time0_[MXTR+1];
type_Ellipsoid     xyz_Ellip[MXTR+1],xyz_Ellip_DP[T_MXS+1];
typexyz            fxyz_spring[2],F_spring_[MAXNb],dfxyz_spring[2],dF_spring1_[MAXNb],dF_spring2_[MAXNb];
typexyz            Fevij_[MAXNb], dFevij_[MAXNb][MAXNb], F_Brown_[MAXNb], dF_Brown_[MAXNb];
typexyz            OMEGAP_[MXTR][MAXNb], ORIENP_[MXTR][MAXNb];
double             *MomegaX_,*MomegaY_,*MomegaZ_,*Meps1P_,*Meps2P_,*Meps3P_,*MetaP_,*MSlope_,*MtempF_,*MTstep_;
double             *Mtime_,*Mtime0_,*MActE_;
int                *McellType_,*Mcount_;
typevariables      FPLo_[T_MXS+1][MAXNb];
typeseed           Seed_[T_MXS+1];
typeseed2          *Muvw_, *Mxyz_, quater_[MXTR][MAXNb];
typeseed3          RadVar_[T_MXS+1];
typexyz            Ip_cell_[T_MXS+1];
typeseed2          FPEPS_[T_MXS+1][MAXNb]; 
double            GVX_[8*MAXNb],DFdt0_[8*MAXNb], g1_[8*MAXNb], g2_[8*MAXNb], g3_[8*MAXNb], g4_[8*MAXNb], AA_[64*MAXNb*MAXNb],AA0_[64*MAXNb*MAXNb];
double             uvxyn_[8*MAXNb+2],uvxy_[8*MAXNb];
typexyz            xyzPress_[MAXNb], xyzPP_[MAXNb];
typexyz            xyzPP0_[MAXNb],xyzPP1_[MAXNb],xyzPP2_[MAXNb],xyzPP3_[MAXNb];
typexyz            uvwP1_[MAXNb],uvwP2_[MAXNb],uvwP0_[MAXNb];
typexyz            uvwF1_[MAXNb],uvwF2_[MAXNb],uvwF3_[MAXNb];
typexyz            aP1_[MAXNb],aP2_[MAXNb],aP3_[MAXNb];
typexyz            aF1_[MAXNb],aF2_[MAXNb],aF3_[MAXNb];
typexyz            omP1_[MAXNb],omP2_[MAXNb],omP3_[MAXNb];
typexyz            OrienP1_[MAXNb],OrienP2_[MAXNb];
typexyz            uvwPP_[MAXNb], uvwF0_[MAXNb], omegaP_[MAXNb];
typeseed2          epsP_[MAXNb];
typeseed2          epsP1_[MAXNb],epsP2_[MAXNb],epsP3_[MAXNb];
typescalar        tPP_[MAXNb],alpha_chPP_[MAXNb], tF0_[MAXNb],tF1_[MAXNb];
typescalar        tP1_[MAXNb],tP2_[MAXNb],tP0_[MAXNb];
typescalar        dtP1_[MAXNb],dtP2_[MAXNb],dtP3_[MAXNb];
typescalar        dtFdt1_[MAXNb],dtFdt2_[MAXNb],dtFdt3_[MAXNb];
typescalar        alpha_chP1_[MAXNb],alpha_chP2_[MAXNb],alpha_chP3_[MAXNb];
int               index_[13*MAXNb];
int               lopas[MAXNb];
double            arlx[15];	
const int tetra[5][4]={{4,5,2,1},{7,2,5,6},{2,7,4,3},{5,4,7,8},{2,4,5,7}};
const int cpit4[1][4]={{1,2,3,4}};
const int cpit5[2][4]={{1,3,5,4},{1,3,5,2}};
const int ocpi5[2][1]={{2},{4}};
const int cpit6[3][4]={{1,6,5,4},{1,5,3,2},{1,3,6,5}};
const int ocpi6[3][2]={{2,3},{4,6},{2,4}};
const int other[5][4]={{6,7,8,3},{1,3,4,8},{1,5,6,8},{1,2,3,6},{1,6,3,8}};
const int other2[3][1]={{3},{1},{1}};
int	  od[6]={6,4,2,5,3,1};
int	  od2[6]={1,3,5,6,2,4};
int	  od3[6]={4,2,6,3,5,1};
//structure of a record(148):time_(14),tstep(14):lopa(8):xp(14),yp(14),zp(14),up(14),vp(14),wp(14),act(14),weight(14);
char  recform1[] ="%14e%14e%8d%14e%14e%14e%14e%14e%14e%14e%14e";
char  recform2[] ="%14lf%14lf%8d%14lf%14lf%14lf%14lf%14lf%14lf%14lf%14lf";
char  dspform[] ="%-e %e %6d %e %e %e %e %e %e %e %e";
int  iPath;
int   id;
static int iset=0;
static double gset;
double fac_g,rsq_g,v1_g,v2_g;
int Brown_c;
double  dzy,dyx,wzy,wxz,wyx;
double  Minor_a,Major_b,Beta_ab;
  char rfm1[81]="%lf\n"; 
  char rfm2[81]="%lf %lf\n"; 
  char rfm3[81]="%lf %lf %lf\n"; 
  char rfm4[81]="%lf %lf %lf %lf\n"; 
  char rfm5[81]="%lf %lf %lf %lf %lf\n"; 
  char rfm6[81]="%lf %lf %lf %lf %lf %lf\n"; 
  char rfm7[81]="%lf %lf %lf %lf %lf %lf %lf\n"; 
  char rfm8[81]="%lf %lf %lf %lf %lf %lf %lf %lf\n"; 
  char rfm9[81]="%lf %lf %lf %lf %lf %lf %lf %lf %lf\n"; 
  char ifm1[81]="%d\n";
  char ifm2[81]="%d %d\n";
  char ifm3[81]="%d %d %d\n";
  char ifm4[81]="%d %d %d %d\n";
  char ifm5[81]="%d %d %d %d %d\n";
  char ifm6[81]="%d %d %d %d %d %d\n";
  char ifm7[81]="%d %d %d %d %d %d %d\n";
  char ifm8[81]="%d %d %d %d %d %d %d %d\n";
  char ifm9[81]="%d %d %d %d %d %d %d %d %d\n";
  char ifm10[81]="%d %d %d %d %d %d %d %d %d %d\n";

/*------------------------------------------------------------------------*/
  char sfm9[81]="%d %lf %lf %lf %lf %lf %lf %lf %lf\n";
/**************************************************************************/
void loadgeom0()
/**************************************************************************/
{
  

  out(f,"\n ---------------------------------------------------------------"
        "\n     WELCOME TO Cell Dynamic Solver for Microfluidics."
		"\n                 Polymerase Chain Reaction Chip."
        "\n       Biomedical Microdevices and Microenvironments Laboratory."      
        "\n             Department of BioMedical Engineering"      
        "\n                    Boston University"      
        "\n"      
        "\n        "
		"\n         This program was developed by Min-Cheol Kim, Ph.D."
        "\n ---------------------------------------------------------------"
        "\n"
        "\n  ENTER YOUR JOB NAME \? "); gets(jobname);


  if(strlen(jobname) == 0) strcat(jobname,"job");
  strcpy(jobvertex,jobname); strcat(jobvertex,".vrt");
  strcpy(jobcell,jobname); strcat(jobcell,".cel");
  strcpy(jobbound,jobname); strcat(jobbound,".bnd");
  strcpy(jobbound2,jobname); strcat(jobbound2,".bnd2");
  strcpy(jobconnect,jobname); strcat(jobconnect,".con");
  strcpy(jobvertexbc,jobname); strcat(jobvertexbc,".vbc");
  strcpy(jobprob,jobname); strcat(jobprob,".prb");
  strcpy(jobcset,jobname); strcat(jobcset,".cst");
  strcpy(jobfemlab1,jobname); strcat(jobfemlab1,".gfl");
  strcpy(jobfemlab2,jobname); strcat(jobfemlab2,".bfl");
  strcpy(jobcollision ,jobname); strcat(jobcollision ,".col");
  strcpy(jobdeposition ,jobname); strcat(jobdeposition ,".dps");

 // Loading Problem

  ifrdev(jobprob) { out(f,"\n *ERROR-UNABLE TO OPEN %s", jobprob); exit(1); }
  else              out(f,"\n LOADING PROBLEM  DATA FROM FILE %s\n",
                           jobprob);

  skip(8); fscanf(rdev,ifm7, &menu,&effect,&TrackWrite,&WallPara_Cal,&TrackRead,&opengl,&tecplot);
  skip(3); fscanf(rdev,"%d %d %d\n",&Mesh, &starcd, &femlab);

  skip(3); fscanf(rdev,"%lf %lf %d %d %d %d %d\n", &NearWLength,&rhop,&Diffuse, &Magnet,&DEP,&heat);
  skip(3); fscanf(rdev,"%d %d %lf %lf %d %d %d\n",&STEADY, &NEWTONIAN,&T,&TimeStep,&iter,&Interpolation,&data_type);

  printf(" number of uvw file in case of transient flow:  %d \n", (int)(RoundOff(T/TimeStep)));
  
  skip(3); fscanf(rdev,rfm4, &rho,&mu, &SCALE, &Hemoto);

  skip(3); fscanf(rdev,ifm6, &Dep,&RV, &TempInt, &SLIP, &MaxIter, &Restart);
  skip(3); fscanf(rdev,ifm2,&s_time, &e_time);
  skip(2); fscanf(rdev,ifm4,&s_np, &e_np, &inc_np,&BFT1);

  skip(3); fscanf(rdev,ifm10, &U_tecplot, &V_tecplot, &W_tecplot, &T_tecplot,&MWSS_tecplot, &AWSS_tecplot,&OSI_tecplot, &VRT_tecplot, &NWDP_tecplot,&BF);
  skip(3); fscanf(rdev,"%lf %d %d %d\n",&Time_P,&S_P,&E_P,&Inc_P);
 
  skip(3); fscanf(rdev,"%lf %lf %lf %d\n",&MovieStartT,&MovieEndT, &MovieDT, &NumMovieFrame);
  skip(3); fscanf(rdev,ifm2, &freq_out, &mon_iter);
  skip(3); fscanf(rdev,rfm5, &T_anneal,&T_melting,&T_extension,&H_heater,&L_heater);

  if(RV==1)   printf("Radius of particles are variable \n");
  else
  {

  }
  omega = 2.*PI/T;
  nu = mu/rho; 
  alpha = rho/rhop;
  beta = 1./(1.+0.5*alpha);  
  fclose(rdev);
 }

/**************************************************************************/
  real Area(int icp)
/**************************************************************************/
{
	  double a[3],b[3],c[3],d[3], temp1[3],temp2[3];
	  int k;
	  int nv1,nv2,nv3,nv4,B_len;

	  B_len=Bound_Length(icp);
	  
	  nv1=BoundJ(icp,1);  
      nv2=BoundJ(icp,2);  
      nv3=BoundJ(icp,3);  
	  if(B_len>3)  nv4=BoundJ(icp,4);
	  else         nv4=-1;
	  
	  if(nv4!=-1)
	  {
		  for(k=0; k<3; k++)  
    	  {
	    	  a[k]=vertex(nv3,k+1)-vertex(nv2,k+1);
		      b[k]=vertex(nv1,k+1)-vertex(nv2,k+1);
              c[k]=vertex(nv1,k+1)-vertex(nv4,k+1);
		      d[k]=vertex(nv3,k+1)-vertex(nv4,k+1);
	      }
		   Cross(a,b,temp1);
	       Cross(c,d,temp2);
	       return  ( 0.5*(sqrt(Dot(temp1,temp1))+sqrt(Dot(temp2,temp2)) ) );
	  }
	  else
	  {
		  for(k=0; k<3; k++)  
    	  {
	    	  a[k]=vertex(nv3,k+1)-vertex(nv2,k+1);
		      b[k]=vertex(nv1,k+1)-vertex(nv2,k+1);
	      }
		  Cross(a,b,temp1);
		  return  ( 0.5*sqrt(Dot(temp1,temp1))  );
	  }
  }
	
/**************************************************************************/
 void loadCFDdata()  // CFD data based on Vertex
/**************************************************************************/
 {
	 real u1,v1,w1,temp1;
	 int  i,n,nv,max_nv;
	 char s[100];
	 double max1, max2, max3, max4;
	 double min1, min2, min3, min4;
	 
	 double xyz1[3];

//	 out(f,"\n  ENTER YOUR CFD data NAME \? "); gets(CFDname);

	 if(data_type==Vertex_f)
	 {
		 verU_=new double[MXV];
	     verV_=new double[MXV];
	     verW_=new double[MXV];
	     verT_=new double[MXV];
	 }
	 else if(data_type==Cell_f)
	 {
		 cellU_=new double[MXC];
	     cellV_=new double[MXC];
	     cellW_=new double[MXC];
	     cellT_=new double[MXC];
		 cellcenter_=new double[3*MXC];
	 }


	 max1=smallest;
	 max2=smallest;
	 max3=smallest;
	 max4=smallest;
	 min1=Large;
	 min2=Large;
	 min3=Large;
	 min4=Large;

	 if(data_type==Vertex_f)  
	 {
		 i=1;
		 max_nv=MXV;
	 }
	 else if(data_type==Cell_f)  
	 {
		 i=2;
		 max_nv=MXC;
		 Interpolation=InverseD;
	 }
	 
		 sprintf(s,"_%d.usr",i);
		 strcpy(jobCFDdata,jobname); strcat(jobCFDdata,s);
	     ifrdev(jobCFDdata) { out(f,"\n *ERROR-UNABLE TO OPEN"); exit(1); }
	
         out(f,"\n LOADING VERTEX DATA FROM FILE %s\n", jobCFDdata);
		 for(n=1; n <= max_nv; n++)
		 {
			 fscanf(rdev,"%d %lf %lf %lf", &nv,&u1,&v1,&w1);
			 if(heat) fscanf(rdev,"%lf",&temp1);
			 else     temp1=293.0;
			                     
             if(data_type==Vertex_f)  
	         {
				 verU(i,n)=u1;
		         verV(i,n)=v1;
			     verW(i,n)=w1;
			     verT(i,n)=temp1;
			 }
			 else if(data_type==Cell_f)  
			 {
				 cellU(n)=u1;
		         cellV(n)=v1;
			     cellW(n)=w1;
			     cellT(n)=temp1;
				 Ccenter(n, xyz1);
				 cellcenterX(n)=xyz1[0];
				 cellcenterY(n)=xyz1[1];
				 cellcenterZ(n)=xyz1[2];
			 }
			
			 max1=MAX(max1,u1);
			 min1=MIN(min1,u1);
			 max2=MAX(max2,v1);
			 min2=MIN(min2,v1);
			 max3=MAX(max3,w1);
			 min3=MIN(min3,w1);
			 max4=MAX(max4,temp1);
			 min4=MIN(min4,temp1);		
		 }
		 fclose(rdev);
	 out(f,"\n Loading CFD finished  \n");
	 if(heat)  out(f,"\n Loading Temperature finished  \n");
	 out(f,"\n max U velocity: %lf  m/s \n",max1);
	 out(f,"   min U velocity: %lf  m/s \n",min1);
	 out(f,"\n max V velocity: %lf  m/s \n",max2);
	 out(f,"   min V velocity: %lf  m/s \n",min2);
	 out(f,"\n max W velocity: %lf  m/s \n",max3);
	 out(f,"   min W velocity: %lf  m/s \n",min3);
	 out(f,"\n max temperature: %lf  oC \n",max4);
	 out(f,"   min temperature: %lf  oC \n",min4);

	 VelU_max=max1;
	 VelV_max=max2;
	 VelW_max=max3;
	 VelU_min=min1;
	 VelV_min=min2;
	 VelW_min=min3;
	 Vel_max=sqrt(VelU_max*VelU_max+VelV_max*VelV_max+VelW_max*VelW_max);
	 VelMAX=sqrt(max1*max1+max2+max2+max3*max3);
	 LengMAX=1.0e-2/VelMAX;
}

 
/**************************************************************************/
 void loadSeed()  // Loading Seeding points
/**************************************************************************/
{
	 real r1,r2,x1,y1,z1,t1, r0;
	 int n,ns, n0, i,ctype;
	 char s[100];
 
	 for(i=1; i<=1; i++)
	 {
		 sprintf(s,"_%d.seed",i);
         strcpy(jobSeed,jobname); strcat(jobSeed,s);
	     ifrdev(jobSeed) { out(f,"\n *ERROR-UNABLE TO OPEN"); exit(1); }
	
         out(f,"\n LOADING SEED POINTS FROM FILE %s\n", jobSeed);
		 fscanf(rdev,"%d ", &Lo_Seed);
         for(n=1; n <=T_MXS; n++)
		 {
			 fscanf(rdev,"%d %d %lf %lf %lf %lf %lf %lf", &ns,&ctype,&r1,&r2,&x1,&y1,&z1,&t1);
             SeedX(n)=x1;
		     SeedY(n)=y1;
		     SeedZ(n)=z1;
			 SeedTime(n)=t1;
			 Rpvar1(n)=r1;
			 Rpvar2(n)=r2;
			 celltype(n)=ctype;


			 if(ctype==Ellipsoid) 
			 {
				 Minor_a=Rpvar1(n);
		         Major_b=Rpvar2(n);
				 Beta_ab=Major_b/Minor_a;
				 beta_ab2=Beta_ab*Beta_ab;
				 Vpvar(n) = 4.*PI*Minor_a*Minor_a*Minor_a*Beta_ab/3.;
				 Mpvar(n) = rhop*Vpvar(n);
                 Ipx(n)=0.2*Mpvar(n)*(1.+ beta_ab2)*Minor_a*Minor_a;
				 Ipy(n)=0.4*Mpvar(n)*Minor_a*Minor_a;
				 Ipz(n)=Ipx(n);   
			 }
			 if(feof(rdev))  
	         {
				 MXS = n-1;
		         break;
	         }
		 }
		 fclose(rdev);
	 }
}

/**************************************************************************/
void AA( int i,int j)
/**************************************************************************/
{
	if(CPIT(i)==4)
	{
		switch (j)
	    {
	    case 1:
			Vlist(1)=cellJ(i,1);
            Vlist(2)=cellJ(i,3);
		    Vlist(3)=cellJ(i,2);
			Vlist(4)=-1;
			break;
	    case 2:
		    Vlist(1)=-1;
		    Vlist(2)=-1;
		    Vlist(3)=-1;
			Vlist(4)=-1;
		    break;
	    case 3:
		    Vlist(1)=cellJ(i,1);
		    Vlist(2)=cellJ(i,2);
		    Vlist(3)=cellJ(i,4);
			Vlist(4)=-1;
			break;
	    case 4:
		    Vlist(1)=-1;
		    Vlist(2)=-1;
		    Vlist(3)=-1;
			Vlist(4)=-1;
			break;
	    case 5:
			Vlist(1)=cellJ(i,1);
			Vlist(2)=cellJ(i,4);
		    Vlist(3)=cellJ(i,3);
			Vlist(4)=-1;
	    	break;
	    case 6:
		    Vlist(1)=cellJ(i,2);
		    Vlist(2)=cellJ(i,3);
		    Vlist(3)=cellJ(i,4);
			Vlist(4)=-1;
		break;
		}
	}
	else if(CPIT(i)==5)
	{
		switch (j)
	    {
	    case 1:
			Vlist(1)=cellJ(i,1);
            Vlist(2)=cellJ(i,4);
		    Vlist(3)=cellJ(i,3);
			Vlist(4)=cellJ(i,2);
			break;
	    case 2:
		    Vlist(1)=-1;
		    Vlist(2)=-1;
		    Vlist(3)=-1;
			Vlist(4)=-1;
		    break;
	    case 3:
		    Vlist(1)=cellJ(i,1);
		    Vlist(2)=cellJ(i,2);
		    Vlist(3)=cellJ(i,5);
			Vlist(4)=-1;
			break;
	    case 4:
		    Vlist(1)=cellJ(i,5);
		    Vlist(2)=cellJ(i,3);
		    Vlist(3)=cellJ(i,4);
			Vlist(4)=-1;
			break;
	    case 5:
			Vlist(1)=cellJ(i,1);
			Vlist(2)=cellJ(i,5);
		    Vlist(3)=cellJ(i,4);
			Vlist(4)=-1;
	    	break;
	    case 6:
		    Vlist(1)=cellJ(i,2);
		    Vlist(2)=cellJ(i,3);
		    Vlist(3)=cellJ(i,5);
			Vlist(4)=-1;
		break;
		}
	}
	else if(CPIT(i)==6)
	{
		switch (j)
	    {
	    case 1:
			Vlist(1)=cellJ(i,1);
            Vlist(2)=cellJ(i,3);
		    Vlist(3)=cellJ(i,2);
			Vlist(4)=-1;
			break;
	    case 2:
		    Vlist(1)=cellJ(i,4);
		    Vlist(2)=cellJ(i,5);
		    Vlist(3)=cellJ(i,6);
			Vlist(4)=-1;
		    break;
	    case 3:
		    Vlist(1)=cellJ(i,1);
		    Vlist(2)=cellJ(i,2);
		    Vlist(3)=cellJ(i,5);
			Vlist(4)=cellJ(i,4);
			break;
	    case 4:
		    Vlist(1)=-1;
		    Vlist(2)=-1;
		    Vlist(3)=-1;
			Vlist(4)=-1;
			break;
	    case 5:
			Vlist(1)=cellJ(i,1);
			Vlist(2)=cellJ(i,4);
		    Vlist(3)=cellJ(i,6);
			Vlist(4)=cellJ(i,3);
	    	break;
	    case 6:
		    Vlist(1)=cellJ(i,2);
		    Vlist(2)=cellJ(i,3);
		    Vlist(3)=cellJ(i,6);
			Vlist(4)=cellJ(i,5);
		break;
		}
	}
	else
	{

	switch (j)
	{
	case 1:
		Vlist(1)=cellJ(i,3);
        Vlist(2)=cellJ(i,2);
		Vlist(3)=cellJ(i,6);
		Vlist(4)=cellJ(i,7);
		
		break;
	case 2:
		Vlist(1)=cellJ(i,1);
		Vlist(2)=cellJ(i,4);
		Vlist(3)=cellJ(i,8);
		Vlist(4)=cellJ(i,5);
		break;
	case 3:
		Vlist(1)=cellJ(i,4);
		Vlist(2)=cellJ(i,3);
		Vlist(3)=cellJ(i,7);
		Vlist(4)=cellJ(i,8);
		break;
	case 4:
		Vlist(1)=cellJ(i,2);
		Vlist(2)=cellJ(i,1);
		Vlist(3)=cellJ(i,5);
		Vlist(4)=cellJ(i,6);
		
		break;
	case 5:
		Vlist(1)=cellJ(i,6);
		Vlist(2)=cellJ(i,5);
		Vlist(3)=cellJ(i,8);
		Vlist(4)=cellJ(i,7);
		
		break;
	case 6:
		Vlist(1)=cellJ(i,1);
		Vlist(2)=cellJ(i,2);
		Vlist(3)=cellJ(i,3);
		Vlist(4)=cellJ(i,4);	
		break;
	}
	}
}


/**************************************************************************/
void Cross(double xyz0[], double xyz1[], double temp[])  // cross product
/**************************************************************************/
{
	double x0,y0,z0,x1,y1,z1;
	x0=xyz0[0]; y0=xyz0[1]; z0=xyz0[2];
	x1=xyz1[0]; y1=xyz1[1]; z1=xyz1[2];

	temp[0]=-(y1*z0) + y0*z1;
	temp[1]=x1*z0 - x0*z1;
	temp[2]=-(x1*y0) + x0*y1;
}
/**************************************************************************/
double Dot(double xyz0[], double xyz1[])   // dot product
/**************************************************************************/
{
	double result;
	double x0,y0,z0,x1,y1,z1;
	x0=xyz0[0]; y0=xyz0[1]; z0=xyz0[2];
	x1=xyz1[0]; y1=xyz1[1]; z1=xyz1[2];
	result=x0*x1 + y0*y1 + z0*z1;
	return result;
}
/**************************************************************************/
double Dotn(double xyz0[], double xyz1[], int n)
/**************************************************************************/
{
	int i;
	double k;
	
	k=0;
	for(i=0; i<n; i++)
	{
		k=k+xyz0[i]*xyz1[i];
	}
	return k;
}
/**************************************************************************/
void  VecPlus(double v1[],double v2[], double temp[])
/**************************************************************************/
{
	double x1,x2,y1,y2,z1,z2;
	x1=v1[0]; y1=v1[1]; z1=v1[2];
	x2=v2[0]; y2=v2[1]; z2=v2[2];
	temp[0]=x1+x2; 
	temp[1]=y1+y2; 
	temp[2]=z1+z2;
}
/**************************************************************************/
void  VecMinus(double v1[],double v2[], double temp[])     /*  v1-v2  */
/**************************************************************************/
{
	double x1,x2,y1,y2,z1,z2;
	x1=v1[0]; y1=v1[1]; z1=v1[2];
	x2=v2[0]; y2=v2[1]; z2=v2[2];
	temp[0]=x1-x2; 
	temp[1]=y1-y2; 
	temp[2]=z1-z2;	
}
/**************************************************************************/
void Nvec(int i, int j, double temp[])  // normal unit vect at the surface of grid
/**************************************************************************/
{
	int  k, l, cb, cbb, kk, flag;
	int  m;	
	flag=0;
	cb=cboundJ(i,j);
	if(cb<0)   
	{
		Nvec2(-cb,temp);
		goto lab1;
	}
	else
	{
		if(i>cb)
		{
			flag=1;
		    for(kk=1; kk<=6; kk++)
		    {
				cbb=cboundJ(cb,kk);
			    if(cbb==i) 
			    {
					AA(cb,kk);
			    	break;
			    }
		    }
		}
		else   AA(i,j);
	}  
	for(k=0; k<4; k++)
	{
		m=Vlist(k+1);
		if(m!=-1)
		{
			for(l=0; l<3; l++)   VXYZ(k,l)=vertex(m,l+1);
		}
	}
	if(Vlist(4)!=-1)
	{
		VecMinus(VXYZ_[2],VXYZ_[0],tmp1_);
	    VecMinus(VXYZ_[1],VXYZ_[3],tmp2_);       
	}
	else
	{
		VecMinus(VXYZ_[1],VXYZ_[0],tmp2_);
	    VecMinus(VXYZ_[2],VXYZ_[0],tmp1_);
	}
	Cross(tmp1_,tmp2_,tmp4_);
	mag=sqrt(Dot(tmp4_,tmp4_));
	
	if(mag==0.) for(k=0; k<3; k++)  temp[k]=0.;
	else        for(k=0; k<3; k++)  temp[k]=tmp4(k)/mag;

	if(flag==1)   for(k=0; k<3; k++)  temp[k]*=-1;

lab1:
	;

}
/**************************************************************************/
void Nvec2(int i, double temp[])   /* Normal Vector in Boundary  */
/**************************************************************************/
{
	int  k, l;

	int  m,B_len;

	B_len=Bound_Length(i);

	for(k=1; k<=B_len; k++)
	{
		m=BoundJ(i,k);
		if(m!=-1)
		{
			for(l=0; l<3; l++)   VXYZ(k-1,l)=vertex(m,l+1);
		}
	}

	if(B_len>3)
	{
		VecMinus(VXYZ_[2],VXYZ_[0],tmp1_);
	    VecMinus(VXYZ_[1],VXYZ_[3],tmp2_);       
	}
	else
	{
		VecMinus(VXYZ_[1],VXYZ_[0],tmp2_);
	    VecMinus(VXYZ_[2],VXYZ_[0],tmp1_);
	}
	Cross(tmp1_,tmp2_,tmp4_);
	mag=sqrt(Dot(tmp4_,tmp4_));
	
	if(mag==0.) for(k=0; k<3; k++)  temp[k]=0.;
	else        for(k=0; k<3; k++)  temp[k]=tmp4(k)/mag;
}			
/**************************************************************************/
int SubtractSet(int A[],int n, int B[], int m)    
/**************************************************************************/
{
	int i,j, flag, count, result;

	count=0;
	for(i=0; i<CPIT(n); i++)
	{
		flag = 0;
		for(j=0; j<CPIT(m); j++)
		{
			if(A[i]==B[j])  
			{
				flag=1; 
				break;
			}
		}
		if(flag==0) 
		{
			result = A[i];
			goto lab1;

		}
	}

lab1:
	;

	return  result;

}
/**************************************************************************/
void SubtractSet3(int A[],int n, int B[],int m, int C[])   /*  Pyramid &Prism         */
/**************************************************************************/
{
	int i,j, flag, count;

	count=0;
	for(i=0; i<CPIT(n); i++)   C[i]=0;
	for(i=0; i<CPIT(n); i++)
	{
		flag = 0;
		for(j=0; j<CPIT(m); j++)
		{
			if(A[i]==B[j])  
			{
				flag=1;
				break;
			}
		}
		if(flag==0) 
		{
			count=count+1;
			C[count-1]=A[i];
		}
	}

}
/**************************************************************************/
double VecMag(double xyz0[])
/**************************************************************************/
{
	return (sqrt(Dot(xyz0,xyz0)));
}
/**************************************************************************/
int  InewTetra(double xyz[], int i)
/**************************************************************************/
{
	int      l, count;
	int      I1,I2, k, a, ii, cc;
   

	count=0;
Start:
	l=i;

	if(WallCell2(l)==3)
	{
		count++;
		Mix(od2);
	
	    if(count>=1000)    
		{
			if(count%100==0)
			{
			
			out(f,"%d: searching order is randomly rearraged   \n", count);
			out(f2,"%d: searching order is randomly rearraged   \n", count);
			if(count >= 600)   goto Finish;
			}
		}
        a=0;
		cc=0;
		for(k=0; k<6; k++)
		{   
		    if(cboundJ(l,od2[k])!=0)
			{
				I1=Mindist1(l,od2[k],xyz);
			}
			else
			{
				a=a+1;
				goto lab1;
			}
			
			
	        if(I1==-1)
			{
				i=cboundJ(l,od2[k]);
				if(count<1000) 
				{
					if(i>0)      break;		
				}
				
			}
			else if(I1==1)
			{
				a=a+1;	
			}
			else if(I1==0)
			{
				cc=1;
			    I2=Mindist2(l,od2[k],xyz);

				if(I2==0)
				{
					ii=cboundJ(l,od2[k]);	
				}
				else   ii=l;
				
			}  
lab1:
			;
		}
		if(count>=1000)
		{
			
				if( a==5 ) 
			    {
					if(cc==1)
				    {
						i=ii;
			            goto Finish;
				    }
			        else   goto  Finish;
			    }
		
		}
	}
	else
	{
		count++;
		Mix(od2);


	    if(count>=500) 
		{
			if(count%100==0)
			{
			
			out(f,"%d: searching order is randomly rearraged   \n",count);
			out(f2,"%d: searching order is randomly rearraged   \n",count);
            if(count >= 600)   goto Finish;
			}
		}
    
		a=0;
		cc=0;
		for(k=0; k<6; k++)
		{
			if(cboundJ(l,od2[k])!=0)
		    {
				I1=Mindist1(l,od2[k],xyz);
			}
			else   
			{
			    a=a+1;
				goto lab2;
			}
				      
	        if(I1==-1)
			{
				i=cboundJ(l,od2[k]);
			
                break;
				
			}
			else if(I1==1)
			{
				a=a+1;
			}
			else if(I1==0)
			{
				cc=1;
				if(count%2==1)          I2=Mindist2(l,od2[k],xyz);
				else                    I2=Mindist2(l,od2[k],xyz);   
				if(I2==0)
				{
					ii=cboundJ(l,od2[k]);
			
				}
				else  ii=l;
			}   
lab2:
			;
		}
        if(count>=500)
		{
			
				if( a==5 ) 
			    {
					if(cc==1)
				    {
						i=ii;
			            goto Finish;
				    }
			        else   goto  Finish;
			    }
			
			
		}
	}
	


	if(i < 0)  
		goto Finish;
	else    
	{
		if(i==l )    
		{  
			goto Finish;
		}
		else    	goto Start;
	}

Finish:			
		
	return i;

}
/**************************************************************************/
double TriPlane(int vlist[],double plist[])
/**************************************************************************/
{
	double A[3], B[3], CP[3], tricenter[3];
	double x[3], y[3], z[3];
	double xc, yc, zc;

	int i,m;


	xc=0.;
	yc=0.;
	zc=0.;
	for(i=0; i<3; i++)
	{
		m = vlist[i];
		x[i] = vertexX(m);
		y[i] = vertexY(m);
		z[i] = vertexZ(m);
		xc=xc+x[i];
		yc=yc+y[i];
		zc=zc+z[i];
	}
	xc=xc/3.;
	yc=yc/3.;
	zc=zc/3.;

	A[0]=x[0]-x[1];
	A[1]=y[0]-y[1];
    A[2]=z[0]-z[1];

    B[0]=x[2]-x[1];
	B[1]=y[2]-y[1];
    B[2]=z[2]-z[1];
	
	tricenter[0]=xc;
	tricenter[1]=yc;
	tricenter[2]=zc;
	for(i=0; i<3; i++)
	{
		CP[i]=plist[i]-tricenter[i];
	}
	Cross(A,B,tmp6_);
	DottempCP=Dot(tmp6_,CP);


	return  DottempCP;

}

/**************************************************************************/
double Phi1(double xp, double yp, double zp, double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0,a1,a2,a3;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

    
	a0=(-(x4*y3*z2) + x3*y4*z2 + x4*y2*z3 - x2*y4*z3 - 
     x3*y2*z4 + x2*y3*z4)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + 
     x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + 
     x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
     x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
     x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	a1=(y3*z2 - y4*z2 - y2*z3 + y4*z3 + y2*z4 - y3*z4)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + 
     x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + 
     x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
     x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
     x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	a2=(-(x3*z2) + x4*z2 + x2*z3 - x4*z3 - x2*z4 + x3*z4)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + 
     x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + 
     x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
     x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
     x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	a3=(x3*y2 - x4*y2 - x2*y3 + x4*y3 + x2*y4 - x3*y4)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + 
     x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + 
     x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
     x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
     x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);  

	 return (a0 + a1*xp + a2*yp + a3*zp);

}
/**************************************************************************/
void Find_transform_coordinate_tetra(double xp, double yp, double zp, double xyz[], double eta1[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;

	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

    
	eta1[0]=((-y1 + yp)*(x3*z1 - x4*z1 - x1*z3 + x4*z3 + x1*z4 - x3*z4))/
    (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - 
      x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
      x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - 
      x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)\
    + ((-x1 + xp)*(-(y3*z1) + y4*z1 + y1*z3 - y4*z3 - y1*z4 + y3*z4))/
    (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - 
      x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
      x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - 
      x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)\
    + ((-(x3*y1) + x4*y1 + x1*y3 - x4*y3 - x1*y4 + x3*y4)*(-z1 + zp))/
    (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - 
      x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
      x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - 
      x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	eta1[1]=((-y1 + yp)*(-(x2*z1) + x4*z1 + x1*z2 - x4*z2 - x1*z4 + x2*z4))/
    (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - 
      x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
      x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - 
      x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)\
    + ((-x1 + xp)*(y2*z1 - y4*z1 - y1*z2 + y4*z2 + y1*z4 - y2*z4))/
    (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - 
      x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
      x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - 
      x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)\
    + ((x2*y1 - x4*y1 - x1*y2 + x4*y2 + x1*y4 - x2*y4)*(-z1 + zp))/
    (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - 
      x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
      x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - 
      x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	eta1[2]=((-y1 + yp)*(x2*z1 - x3*z1 - x1*z2 + x3*z2 + x1*z3 - x2*z3))/
    (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - 
      x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
      x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - 
      x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)\
    + ((-x1 + xp)*(-(y2*z1) + y3*z1 + y1*z2 - y3*z2 - y1*z3 + y2*z3))/
    (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - 
      x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
      x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - 
      x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)\
    + ((-(x2*y1) + x3*y1 + x1*y2 - x3*y2 - x1*y3 + x2*y3)*(-z1 + zp))/
    (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - 
      x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + 
      x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - 
      x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

}
/**************************************************************************/
double Phi2(double xp, double yp, double zp, double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0,a1,a2,a3;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];


	a0=(x4*y3*z1 - x3*y4*z1 - x4*y1*z3 + x1*y4*z3 + x3*y1*z4 - x1*y3*z4)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	a1=(-(y3*z1) + y4*z1 + y1*z3 - y4*z3 - y1*z4 + y3*z4)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	a2=(x3*z1 - x4*z1 - x1*z3 + x4*z3 + x1*z4 - x3*z4)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	a3=(-(x3*y1) + x4*y1 + x1*y3 - x4*y3 - x1*y4 + x3*y4)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	 return (a0 + a1*xp + a2*yp + a3*zp);   
}
/**************************************************************************/
double Phi3(double xp, double yp, double zp, double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0,a1,a2,a3;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];


	a0=(-(x4*y2*z1) + x2*y4*z1 + x4*y1*z2 - x1*y4*z2 - x2*y1*z4 + x1*y2*z4)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	a1=(y2*z1 - y4*z1 - y1*z2 + y4*z2 + y1*z4 - y2*z4)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	a2=(-(x2*z1) + x4*z1 + x1*z2 - x4*z2 - x1*z4 + x2*z4)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	a3=(x2*y1 - x4*y1 - x1*y2 + x4*y2 + x1*y4 - x2*y4)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	 return (a0 + a1*xp + a2*yp + a3*zp); 

}
/**************************************************************************/
double Phi4(double xp, double yp, double zp, double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0,a1,a2,a3;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];
	

	a0=(x3*y2*z1 - x2*y3*z1 - x3*y1*z2 + x1*y3*z2 + x2*y1*z3 - x1*y2*z3)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	a1=(-(y2*z1) + y3*z1 + y1*z2 - y3*z2 - y1*z3 + y2*z3)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	a2=(x2*z1 - x3*z1 - x1*z2 + x3*z2 + x1*z3 - x2*z3)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	a3=(-(x2*y1) + x3*y1 + x1*y2 - x3*y2 - x1*y3 + x2*y3)/
   (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + 
     x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4);

	 return (a0 + a1*xp + a2*yp + a3*zp);   

}
 
/**************************************************************************/
double ddPhiPhiPhi1_xx(real x, real y, real z,double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	

	a0=(4*(y3*z2 - y4*z2 - y2*z3 + y4*z3 + y2*z4 - y3*z4)*
      (-(y3*z1) + y4*z1 + y1*z3 - y4*z3 - y1*z4 + y3*z4)*
      (((-(x3*y1) + x4*y1 + x1*y3 - x4*y3 - x1*y4 + x3*y4)*z)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(x3*z1 - x4*z1 - x1*z3 + x4*z3 + x1*z4 - x3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(-(y3*z1) + y4*z1 + y1*z3 - y4*z3 - y1*z4 + y3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x4*y3*z1 - x3*y4*z1 - x4*y1*z3 + x1*y4*z3 + x3*y1*z4 - 
           x1*y3*z4)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2) + (2*pow(-(y3*z1) + y4*z1 + y1*z3 - y4*z3 - y1*z4 + 
        y3*z4,2)*(((x3*y2 - x4*y2 - x2*y3 + x4*y3 + x2*y4 - x3*y4)*z)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(-(x3*z2) + x4*z2 + x2*z3 - x4*z3 - x2*z4 + x3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(y3*z2 - y4*z2 - y2*z3 + y4*z3 + y2*z4 - y3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (-(x4*y3*z2) + x3*y4*z2 + x4*y2*z3 - x2*y4*z3 - x3*y2*z4 + 
           x2*y3*z4)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2);

	 return (a0);

}
/**************************************************************************/
double ddPhiPhiPhi2_xx(real x, real y, real z,double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];
	a0=(4*(y2*z1 - y4*z1 - y1*z2 + y4*z2 + y1*z4 - y2*z4)*
      (y3*z2 - y4*z2 - y2*z3 + y4*z3 + y2*z4 - y3*z4)*
      (((x2*y1 - x4*y1 - x1*y2 + x4*y2 + x1*y4 - x2*y4)*z)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(-(x2*z1) + x4*z1 + x1*z2 - x4*z2 - x1*z4 + x2*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(y2*z1 - y4*z1 - y1*z2 + y4*z2 + y1*z4 - y2*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (-(x4*y2*z1) + x2*y4*z1 + x4*y1*z2 - x1*y4*z2 - x2*y1*z4 + 
           x1*y2*z4)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2) + (2*pow(y2*z1 - y4*z1 - y1*z2 + y4*z2 + y1*z4 - 
        y2*z4,2)*(((x3*y2 - x4*y2 - x2*y3 + x4*y3 + x2*y4 - x3*y4)*z)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(-(x3*z2) + x4*z2 + x2*z3 - x4*z3 - x2*z4 + x3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(y3*z2 - y4*z2 - y2*z3 + y4*z3 + y2*z4 - y3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (-(x4*y3*z2) + x3*y4*z2 + x4*y2*z3 - x2*y4*z3 - x3*y2*z4 + 
           x2*y3*z4)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2);

	 return (a0);

}
/**************************************************************************/
double ddPhiPhiPhi3_xx(real x, real y, real z,double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	

	a0=(4*(-(y2*z1) + y3*z1 + y1*z2 - y3*z2 - y1*z3 + y2*z3)*
      (y3*z2 - y4*z2 - y2*z3 + y4*z3 + y2*z4 - y3*z4)*
      (((-(x2*y1) + x3*y1 + x1*y2 - x3*y2 - x1*y3 + x2*y3)*z)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(x2*z1 - x3*z1 - x1*z2 + x3*z2 + x1*z3 - x2*z3))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(-(y2*z1) + y3*z1 + y1*z2 - y3*z2 - y1*z3 + y2*z3))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x3*y2*z1 - x2*y3*z1 - x3*y1*z2 + x1*y3*z2 + x2*y1*z3 - 
           x1*y2*z3)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2) + (2*pow(-(y2*z1) + y3*z1 + y1*z2 - y3*z2 - y1*z3 + 
        y2*z3,2)*(((x3*y2 - x4*y2 - x2*y3 + x4*y3 + x2*y4 - x3*y4)*z)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(-(x3*z2) + x4*z2 + x2*z3 - x4*z3 - x2*z4 + x3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(y3*z2 - y4*z2 - y2*z3 + y4*z3 + y2*z4 - y3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (-(x4*y3*z2) + x3*y4*z2 + x4*y2*z3 - x2*y4*z3 - x3*y2*z4 + 
           x2*y3*z4)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2);

	 return (a0);

}
/**************************************************************************/
double ddPhiPhiPhi4_xx(real x, real y, real z,double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	

	a0=(2*pow(y3*z2 - y4*z2 - y2*z3 + y4*z3 + y2*z4 - y3*z4,2)*
      (((-(x3*y1) + x4*y1 + x1*y3 - x4*y3 - x1*y4 + x3*y4)*z)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(x3*z1 - x4*z1 - x1*z3 + x4*z3 + x1*z4 - x3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(-(y3*z1) + y4*z1 + y1*z3 - y4*z3 - y1*z4 + y3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x4*y3*z1 - x3*y4*z1 - x4*y1*z3 + x1*y4*z3 + x3*y1*z4 - 
           x1*y3*z4)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2) + (4*(y3*z2 - y4*z2 - y2*z3 + y4*z3 + y2*z4 - y3*z4)*
      (-(y3*z1) + y4*z1 + y1*z3 - y4*z3 - y1*z4 + y3*z4)*
      (((x3*y2 - x4*y2 - x2*y3 + x4*y3 + x2*y4 - x3*y4)*z)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(-(x3*z2) + x4*z2 + x2*z3 - x4*z3 - x2*z4 + x3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(y3*z2 - y4*z2 - y2*z3 + y4*z3 + y2*z4 - y3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (-(x4*y3*z2) + x3*y4*z2 + x4*y2*z3 - x2*y4*z3 - x3*y2*z4 + 
           x2*y3*z4)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2);

	 return (a0);

}
/**************************************************************************/
double ddPhiPhiPhi5_xx(real x, real y, real z,double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	

	a0=(4*(y2*z1 - y4*z1 - y1*z2 + y4*z2 + y1*z4 - y2*z4)*
      (-(y3*z1) + y4*z1 + y1*z3 - y4*z3 - y1*z4 + y3*z4)*
      (((x2*y1 - x4*y1 - x1*y2 + x4*y2 + x1*y4 - x2*y4)*z)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(-(x2*z1) + x4*z1 + x1*z2 - x4*z2 - x1*z4 + x2*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(y2*z1 - y4*z1 - y1*z2 + y4*z2 + y1*z4 - y2*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (-(x4*y2*z1) + x2*y4*z1 + x4*y1*z2 - x1*y4*z2 - x2*y1*z4 + 
           x1*y2*z4)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2) + (2*pow(y2*z1 - y4*z1 - y1*z2 + y4*z2 + y1*z4 - 
        y2*z4,2)*(((-(x3*y1) + x4*y1 + x1*y3 - x4*y3 - x1*y4 + x3*y4)*
           z)/(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(x3*z1 - x4*z1 - x1*z3 + x4*z3 + x1*z4 - x3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(-(y3*z1) + y4*z1 + y1*z3 - y4*z3 - y1*z4 + y3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x4*y3*z1 - x3*y4*z1 - x4*y1*z3 + x1*y4*z3 + x3*y1*z4 - 
           x1*y3*z4)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2);

	 return (a0);

}

{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	

	a0=(2*(x3*y2 - x4*y2 - x2*y3 + x4*y3 + x2*y4 - x3*y4)*
      (x2*z1 - x3*z1 - x1*z2 + x3*z2 + x1*z3 - x2*z3)*
      (((-(x2*y1) + x3*y1 + x1*y2 - x3*y2 - x1*y3 + x2*y3)*z)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(x2*z1 - x3*z1 - x1*z2 + x3*z2 + x1*z3 - x2*z3))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(-(y2*z1) + y3*z1 + y1*z2 - y3*z2 - y1*z3 + y2*z3))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x3*y2*z1 - x2*y3*z1 - x3*y1*z2 + x1*y3*z2 + x2*y1*z3 - 
           x1*y2*z3)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2) + (2*(-(x2*y1) + x3*y1 + x1*y2 - x3*y2 - x1*y3 + 
        x2*y3)*(-(x3*z2) + x4*z2 + x2*z3 - x4*z3 - x2*z4 + x3*z4)*
      (((-(x2*y1) + x3*y1 + x1*y2 - x3*y2 - x1*y3 + x2*y3)*z)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(x2*z1 - x3*z1 - x1*z2 + x3*z2 + x1*z3 - x2*z3))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(-(y2*z1) + y3*z1 + y1*z2 - y3*z2 - y1*z3 + y2*z3))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x3*y2*z1 - x2*y3*z1 - x3*y1*z2 + x1*y3*z2 + x2*y1*z3 - 
           x1*y2*z3)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2) + (2*(-(x2*y1) + x3*y1 + x1*y2 - x3*y2 - x1*y3 + 
        x2*y3)*(x2*z1 - x3*z1 - x1*z2 + x3*z2 + x1*z3 - x2*z3)*
      (((x3*y2 - x4*y2 - x2*y3 + x4*y3 + x2*y4 - x3*y4)*z)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (y*(-(x3*z2) + x4*z2 + x2*z3 - x4*z3 - x2*z4 + x3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (x*(y3*z2 - y4*z2 - y2*z3 + y4*z3 + y2*z4 - y3*z4))/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4) + 
        (-(x4*y3*z2) + x3*y4*z2 + x4*y2*z3 - x2*y4*z3 - x3*y2*z4 + 
           x2*y3*z4)/
         (x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
           x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - 
           x1*y4*z2 + x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + 
           x4*y2*z3 + x1*y4*z3 - x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + 
           x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + x2*y3*z4)))/
    pow(x3*y2*z1 - x4*y2*z1 - x2*y3*z1 + x4*y3*z1 + x2*y4*z1 - 
      x3*y4*z1 - x3*y1*z2 + x4*y1*z2 + x1*y3*z2 - x4*y3*z2 - x1*y4*z2 + 
      x3*y4*z2 + x2*y1*z3 - x4*y1*z3 - x1*y2*z3 + x4*y2*z3 + x1*y4*z3 - 
      x2*y4*z3 - x2*y1*z4 + x3*y1*z4 + x1*y2*z4 - x3*y2*z4 - x1*y3*z4 + 
      x2*y3*z4,2);

	 return (a0);

}

double ddPhi1Phi2_xx(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];
	
	 a0=(2*(y3*z1 - y4*z1 - y1*z3 + y4*z3 + y1*z4 - y3*z4)*(-(y3*z2) + y4*z2 + y2*z3 - y4*z3 - y2*z4 + y3*z4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi2_yy(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(x3*z2 - x2*z3 + x4*(-z2 + z3) + x2*z4 - x3*z4)*(-(x3*z1) + x4*(z1 - z3) + x1*z3 - x1*z4 + x3*z4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi2_zz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];


	a0=(2*(x3*y1 - x1*y3 + x4*(-y1 + y3) + x1*y4 - x3*y4)*(-(x3*y2) + x4*(y2 - y3) + x2*y3 - x2*y4 + x3*y4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi2_xy(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=((x3*z2 - x2*z3 + x4*(-z2 + z3) + x2*z4 - x3*z4)*(y3*z1 - y4*z1 - y1*z3 + y4*z3 + y1*z4 - y3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((-(x3*z1) + x4*(z1 - z3) + x1*z3 - x1*z4 + x3*z4)*(-(y3*z2) + y4*z2 + y2*z3 - y4*z3 - y2*z4 + y3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi2_xz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];
	
	a0=((-(x3*y2) + x4*(y2 - y3) + x2*y3 - x2*y4 + x3*y4)*(y3*z1 - y4*z1 - y1*z3 + y4*z3 + y1*z4 - y3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((x3*y1 - x1*y3 + x4*(-y1 + y3) + x1*y4 - x3*y4)*(-(y3*z2) + y4*z2 + y2*z3 - y4*z3 - y2*z4 + y3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}

/**************************************************************************/
double ddPhi1Phi2_yz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=((x3*y1 - x1*y3 + x4*(-y1 + y3) + x1*y4 - x3*y4)*(x3*z2 - x2*z3 + x4*(-z2 + z3) + x2*z4 - x3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((-(x3*y2) + x4*(y2 - y3) + x2*y3 - x2*y4 + x3*y4)*(-(x3*z1) + x4*(z1 - z3) + x1*z3 - x1*z4 + x3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);
}

/**************************************************************************/
double ddPhi1Phi3_xx(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(-(y2*z1) + y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*z4)*(-(y3*z2) + y4*z2 + y2*z3 - y4*z3 - y2*z4 + y3*z4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);
 
	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi3_yy(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];


	a0=(2*(x2*z1 - x1*z2 + x4*(-z1 + z2) + x1*z4 - x2*z4)*(x3*z2 - x2*z3 + x4*(-z2 + z3) + x2*z4 - x3*z4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi3_zz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(-(x2*y1) + x4*(y1 - y2) + x1*y2 - x1*y4 + x2*y4)*(-(x3*y2) + x4*(y2 - y3) + x2*y3 - x2*y4 + x3*y4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi3_xy(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=((x3*z2 - x2*z3 + x4*(-z2 + z3) + x2*z4 - x3*z4)*(-(y2*z1) + y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((x2*z1 - x1*z2 + x4*(-z1 + z2) + x1*z4 - x2*z4)*(-(y3*z2) + y4*z2 + y2*z3 - y4*z3 - y2*z4 + y3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi3_xz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=((-(x3*y2) + x4*(y2 - y3) + x2*y3 - x2*y4 + x3*y4)*(-(y2*z1) + y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((-(x2*y1) + x4*(y1 - y2) + x1*y2 - x1*y4 + x2*y4)*(-(y3*z2) + y4*z2 + y2*z3 - y4*z3 - y2*z4 + y3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}

/**************************************************************************/
double ddPhi1Phi3_yz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=((-(x3*y2) + x4*(y2 - y3) + x2*y3 - x2*y4 + x3*y4)*(x2*z1 - x1*z2 + x4*(-z1 + z2) + x1*z4 - x2*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((-(x2*y1) + x4*(y1 - y2) + x1*y2 - x1*y4 + x2*y4)*(x3*z2 - x2*z3 + x4*(-z2 + z3) + x2*z4 - x3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi4_xx(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3)*(-(y3*z2) + y4*z2 + y2*z3 - y4*z3 - y2*z4 + y3*z4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi4_yy(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(-(x2*z1) + x3*(z1 - z2) + x1*z2 - x1*z3 + x2*z3)*(x3*z2 - x2*z3 + x4*(-z2 + z3) + x2*z4 - x3*z4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi4_zz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(x2*y1 - x1*y2 + x3*(-y1 + y2) + x1*y3 - x2*y3)*(-(x3*y2) + x4*(y2 - y3) + x2*y3 - x2*y4 + x3*y4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi4_xy(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=((y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3)*(x3*z2 - x2*z3 + x4*(-z2 + z3) + x2*z4 - x3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((-(x2*z1) + x3*(z1 - z2) + x1*z2 - x1*z3 + x2*z3)*(-(y3*z2) + y4*z2 + y2*z3 - y4*z3 - y2*z4 + y3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi1Phi4_xz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];


	a0=((-(x3*y2) + x4*(y2 - y3) + x2*y3 - x2*y4 + x3*y4)*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((x2*y1 - x1*y2 + x3*(-y1 + y2) + x1*y3 - x2*y3)*(-(y3*z2) + y4*z2 + y2*z3 - y4*z3 - y2*z4 + y3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}

/**************************************************************************/
double ddPhi1Phi4_yz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=((-(x3*y2) + x4*(y2 - y3) + x2*y3 - x2*y4 + x3*y4)*(-(x2*z1) + x3*(z1 - z2) + x1*z2 - x1*z3 + x2*z3))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((x2*y1 - x1*y2 + x3*(-y1 + y2) + x1*y3 - x2*y3)*(x3*z2 - x2*z3 + x4*(-z2 + z3) + x2*z4 - x3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}

/**************************************************************************/
double ddPhi2Phi3_xx(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];
	a0=(2*(-(y2*z1) + y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*z4)*(y3*z1 - y4*z1 - y1*z3 + y4*z3 + y1*z4 - y3*z4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi2Phi3_yy(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(x2*z1 - x1*z2 + x4*(-z1 + z2) + x1*z4 - x2*z4)*(-(x3*z1) + x4*(z1 - z3) + x1*z3 - x1*z4 + x3*z4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi2Phi3_zz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(-(x2*y1) + x4*(y1 - y2) + x1*y2 - x1*y4 + x2*y4)*(x3*y1 - x1*y3 + x4*(-y1 + y3) + x1*y4 - x3*y4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);
	 return (a0);

}
/**************************************************************************/
double ddPhi2Phi3_xy(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];


	a0=((-(x3*z1) + x4*(z1 - z3) + x1*z3 - x1*z4 + x3*z4)*(-(y2*z1) + y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((x2*z1 - x1*z2 + x4*(-z1 + z2) + x1*z4 - x2*z4)*(y3*z1 - y4*z1 - y1*z3 + y4*z3 + y1*z4 - y3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi2Phi3_xz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];


	a0=((x3*y1 - x1*y3 + x4*(-y1 + y3) + x1*y4 - x3*y4)*(-(y2*z1) + y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((-(x2*y1) + x4*(y1 - y2) + x1*y2 - x1*y4 + x2*y4)*(y3*z1 - y4*z1 - y1*z3 + y4*z3 + y1*z4 - y3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}

/**************************************************************************/
double ddPhi2Phi3_yz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=((x3*y1 - x1*y3 + x4*(-y1 + y3) + x1*y4 - x3*y4)*(x2*z1 - x1*z2 + x4*(-z1 + z2) + x1*z4 - x2*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((-(x2*y1) + x4*(y1 - y2) + x1*y2 - x1*y4 + x2*y4)*(-(x3*z1) + x4*(z1 - z3) + x1*z3 - x1*z4 + x3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi2Phi4_xx(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3)*(y3*z1 - y4*z1 - y1*z3 + y4*z3 + y1*z4 - y3*z4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi2Phi4_yy(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(-(x2*z1) + x3*(z1 - z2) + x1*z2 - x1*z3 + x2*z3)*(-(x3*z1) + x4*(z1 - z3) + x1*z3 - x1*z4 + x3*z4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi2Phi4_zz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(x2*y1 - x1*y2 + x3*(-y1 + y2) + x1*y3 - x2*y3)*(x3*y1 - x1*y3 + x4*(-y1 + y3) + x1*y4 - x3*y4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi2Phi4_xy(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=((y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3)*(-(x3*z1) + x4*(z1 - z3) + x1*z3 - x1*z4 + x3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((-(x2*z1) + x3*(z1 - z2) + x1*z2 - x1*z3 + x2*z3)*(y3*z1 - y4*z1 - y1*z3 + y4*z3 + y1*z4 - y3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi2Phi4_xz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=((x3*y1 - x1*y3 + x4*(-y1 + y3) + x1*y4 - x3*y4)*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((x2*y1 - x1*y2 + x3*(-y1 + y2) + x1*y3 - x2*y3)*(y3*z1 - y4*z1 - y1*z3 + y4*z3 + y1*z4 - y3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}

/**************************************************************************/
double ddPhi2Phi4_yz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=((x3*y1 - x1*y3 + x4*(-y1 + y3) + x1*y4 - x3*y4)*(-(x2*z1) + x3*(z1 - z2) + x1*z2 - x1*z3 + x2*z3))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((x2*y1 - x1*y2 + x3*(-y1 + y2) + x1*y3 - x2*y3)*(-(x3*z1) + x4*(z1 - z3) + x1*z3 - x1*z4 + x3*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi3Phi4_xx(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3)*(-(y2*z1) + y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*z4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi3Phi4_yy(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(-(x2*z1) + x3*(z1 - z2) + x1*z2 - x1*z3 + x2*z3)*(x2*z1 - x1*z2 + x4*(-z1 + z2) + x1*z4 - x2*z4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi3Phi4_zz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=(2*(x2*y1 - x1*y2 + x3*(-y1 + y2) + x1*y3 - x2*y3)*(-(x2*y1) + x4*(y1 - y2) + x1*y2 - x1*y4 + x2*y4))/
   pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
     x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
     x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi3Phi4_xy( double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];

	a0=((y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3)*(x2*z1 - x1*z2 + x4*(-z1 + z2) + x1*z4 - x2*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((-(x2*z1) + x3*(z1 - z2) + x1*z2 - x1*z3 + x2*z3)*(-(y2*z1) + y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
double ddPhi3Phi4_xz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];


	a0=((-(x2*y1) + x4*(y1 - y2) + x1*y2 - x1*y4 + x2*y4)*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((x2*y1 - x1*y2 + x3*(-y1 + y2) + x1*y3 - x2*y3)*(-(y2*z1) + y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}

/**************************************************************************/
double ddPhi3Phi4_yz(double xyz[])
/**************************************************************************/
{
	real x1,x2,x3,x4,y1,y2,y3,y4,z1,z2,z3,z4;
	real a0;
	x1=xyz[0]; y1=xyz[1]; z1=xyz[2];
	x2=xyz[3]; y2=xyz[4]; z2=xyz[5];
	x3=xyz[6]; y3=xyz[7]; z3=xyz[8];
	x4=xyz[9]; y4=xyz[10]; z4=xyz[11];


	a0=((-(x2*y1) + x4*(y1 - y2) + x1*y2 - x1*y4 + x2*y4)*(-(x2*z1) + x3*(z1 - z2) + x1*z2 - x1*z3 + x2*z3))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2) + 
   ((x2*y1 - x1*y2 + x3*(-y1 + y2) + x1*y3 - x2*y3)*(x2*z1 - x1*z2 + x4*(-z1 + z2) + x1*z4 - x2*z4))/
    pow(x2*y3*z1 - x2*y4*z1 - x1*y3*z2 + x1*y4*z2 - x2*y1*z3 + x1*y2*z3 - x1*y4*z3 + x2*y4*z3 + 
      x4*(y2*z1 - y3*z1 - y1*z2 + y3*z2 + y1*z3 - y2*z3) + x2*y1*z4 - x1*y2*z4 + x1*y3*z4 - x2*y3*z4 + 
      x3*(y4*z1 + y1*z2 - y4*z2 - y1*z4 + y2*(-z1 + z4)),2);

	 return (a0);

}
/**************************************************************************/
void  LinearQ(double x, double y, double z, double t_xyz[], double t_phi[], double phi_linear[], int vec)
/**************************************************************************/
{
	int i,LenVar;

	double P1, P2, P3, P4;
    
	if(vec==1) LenVar=3;
	else       LenVar=1;
	P1=Phi1(x,y,z, t_xyz);
	P2=Phi2(x,y,z, t_xyz);
	P3=Phi3(x,y,z, t_xyz);
	P4=Phi4(x,y,z, t_xyz);
	for(i=0; i<LenVar; i++)
	{
		phi_linear[i]=P1*t_phi[LenVar*0 + i]+P2*t_phi[LenVar*1 + i]+P3*t_phi[LenVar*2 + i]+P4*t_phi[LenVar*3 + i];
	}
}

/**************************************************************************/
void  LinearQ_tetra(double x, double y, double z, double t_xyz[], double phi[], double phi_linear[], int vec)
/**************************************************************************/
{
	int i,LenVar;

	double eta1[3];
	double u1,u2,u3,u4;
    
	if(vec) LenVar=3;
	else     LenVar=1;

	Find_transform_coordinate_tetra(x, y, z, t_xyz, eta1);

	for(i=0; i<LenVar; i++)
	{
		u1=phi[LenVar*0 + i];
		u2=phi[LenVar*1 + i];
		u3=phi[LenVar*2 + i];
		u4=phi[LenVar*3 + i];
		phi_linear[i]=u1 + (u2-u1)*eta1[0] + (u3-u1)*eta1[1]  +  (u4-u1)*eta1[2];
	}

}
/**************************************************************************/
void DLinearQdx(double xyz[], double uvw[], double temp[],int vec)
/**************************************************************************/
{
	double DuvwDx0[3],DuvwDx1[3];

	int   i, LenVar;

	if(vec)  LenVar=3;
	else     LenVar=1;
	LinearQ(1.,0.,0.,xyz,uvw,DuvwDx0,vec);
    LinearQ(0.,0.,0.,xyz,uvw,DuvwDx1,vec);
	for(i=0; i<LenVar; i++) temp[i]=DuvwDx0[i]-DuvwDx1[i];
}
/**************************************************************************/
void DLinearQdy(double xyz[], double uvw[], double temp[],int vec)
/**************************************************************************/
{
	double DuvwDx0[3],DuvwDx1[3];

	int   i, LenVar;
	if(vec)  LenVar=3;
	else     LenVar=1;
	LinearQ(0.,1.,0.,xyz,uvw,DuvwDx0,vec);
    LinearQ(0.,0.,0.,xyz,uvw,DuvwDx1,vec);
	for(i=0; i<LenVar; i++) temp[i]=DuvwDx0[i]-DuvwDx1[i];
}
/**************************************************************************/
void DLinearQdz(double xyz[], double uvw[], double temp[],int vec)
/**************************************************************************/
{
	double DuvwDx0[3],DuvwDx1[3];
	int   i, LenVar;
	if(vec)  LenVar=3;
	else     LenVar=1;
	LinearQ(0.,0.,1.,xyz,uvw,DuvwDx0,vec);
    LinearQ(0.,0.,0.,xyz,uvw,DuvwDx1,vec);
	for(i=0; i<LenVar; i++) temp[i]=DuvwDx0[i]-DuvwDx1[i];
}
/**************************************************************************/
void  CubicRow(real x, real y, real z, real xyz_tetra[], double temp[])
/**************************************************************************/
{
	double P1, P2, P3, P4;
	P1=Phi1(x,y,z, xyz_tetra);
	P2=Phi2(x,y,z, xyz_tetra);
	P3=Phi3(x,y,z, xyz_tetra);
	P4=Phi4(x,y,z, xyz_tetra); 
	if(Interpolation==Quad)
	{

	 temp[0]=P1*P2;
	    temp[1]=P1*P3;
	    temp[2]=P1*P4;
	    temp[3]=P2*P3;
	    temp[4]=P2*P4;
	    temp[5]=P3*P4;  
	}
}
/**************************************************************************/
void  DCubicRowDx(real x, real y, real z, real xyz[], double temp[])
/**************************************************************************/
{

	double P1, P2, P3, P4;
	double P1x, P2x, P3x, P4x;
	double P10, P20, P30, P40;

	P1=Phi1(x,y,z, xyz);
	P2=Phi2(x,y,z, xyz);
	P3=Phi3(x,y,z, xyz);
	P4=Phi4(x,y,z, xyz);
	P1x=Phi1(1.,0.,0.,xyz);
	P2x=Phi2(1.,0.,0.,xyz);
	P3x=Phi3(1.,0.,0.,xyz);
	P4x=Phi4(1.,0.,0.,xyz);
	P10=Phi1(0.,0.,0.,xyz);
	P20=Phi2(0.,0.,0.,xyz);
	P30=Phi3(0.,0.,0.,xyz);
	P40=Phi4(0.,0.,0.,xyz);  


	if(Interpolation==Quad)
	{
	temp[0]=(P1x - P10)*P2 + P1*(P2x - P20);
	temp[1]=(P1x - P10)*P3 + P1*(P3x - P30);
	temp[2]=(P1x - P10)*P4 + P1*(P4x - P40);
	temp[3]=(P2x - P20)*P3 + P2*(P3x - P30);
	temp[4]=(P2x - P20)*P4 + P2*(P4x - P40);
	temp[5]=(P3x - P30)*P4 + P3*(P4x - P40); 
	}
}
/**************************************************************************/
void  DCubicRowDy(real x, real y, real z, real xyz[], double temp[])
/**************************************************************************/
{

	double P1, P2, P3, P4;
	double P1y, P2y, P3y, P4y;
	double P10, P20, P30, P40;

	P1=Phi1(x,y,z, xyz);
	P2=Phi2(x,y,z, xyz);
	P3=Phi3(x,y,z, xyz);
	P4=Phi4(x,y,z, xyz);
	P1y=Phi1(0.,1.,0.,xyz);
	P2y=Phi2(0.,1.,0.,xyz);
	P3y=Phi3(0.,1.,0.,xyz);
	P4y=Phi4(0.,1.,0.,xyz);
	P10=Phi1(0.,0.,0.,xyz);
	P20=Phi2(0.,0.,0.,xyz);
	P30=Phi3(0.,0.,0.,xyz);
	P40=Phi4(0.,0.,0.,xyz);

	if(Interpolation==Quad)
	{
	temp[0]=(P1y - P10)*P2 + P1*(P2y - P20);
	temp[1]=(P1y - P10)*P3 + P1*(P3y - P30);
	temp[2]=(P1y - P10)*P4 + P1*(P4y - P40);
	temp[3]=(P2y - P20)*P3 + P2*(P3y - P30);
	temp[4]=(P2y - P20)*P4 + P2*(P4y - P40);
	temp[5]=(P3y - P30)*P4 + P3*(P4y - P40);  
	}
}
/**************************************************************************/
void  DCubicRowDz(real x, real y, real z, real xyz[], double temp[])
/**************************************************************************/
{

	double P1, P2, P3, P4;
	double P1z, P2z, P3z, P4z;
	double P10, P20, P30, P40;

    P1=Phi1(x,y,z, xyz);
	P2=Phi2(x,y,z, xyz);
	P3=Phi3(x,y,z, xyz);
	P4=Phi4(x,y,z, xyz);
	P1z=Phi1(0.,0.,1.,xyz);
	P2z=Phi2(0.,0.,1.,xyz);
	P3z=Phi3(0.,0.,1.,xyz);
	P4z=Phi4(0.,0.,1.,xyz);
	P10=Phi1(0.,0.,0.,xyz);
	P20=Phi2(0.,0.,0.,xyz);
	P30=Phi3(0.,0.,0.,xyz);
	P40=Phi4(0.,0.,0.,xyz); 

	if(Interpolation==Quad)
	{
	temp[0]=(P1z - P10)*P2 + P1*(P2z - P20);
	temp[1]=(P1z - P10)*P3 + P1*(P3z - P30);
	temp[2]=(P1z - P10)*P4 + P1*(P4z - P40);
	temp[3]=(P2z - P20)*P3 + P2*(P3z - P30);
	temp[4]=(P2z - P20)*P4 + P2*(P4z - P40);
	temp[5]=(P3z - P30)*P4 + P3*(P4z - P40);
	}  
}
/**************************************************************************/
void  DDCubicRow_xx(real x, real y, real z, real xyz[], double temp[])
/**************************************************************************/
{
	if(Interpolation==Quad)
	{	
	    temp[0]=ddPhi1Phi2_xx(xyz);
	    temp[1]=ddPhi1Phi3_xx(xyz);
	    temp[2]=ddPhi1Phi4_xx(xyz);
	    temp[3]=ddPhi2Phi3_xx(xyz);
	    temp[4]=ddPhi2Phi4_xx(xyz);
	    temp[5]=ddPhi3Phi4_xx(xyz);  
	}
}
/**************************************************************************/
void  DDCubicRow_yy(real x, real y, real z, real xyz[], double temp[])
/**************************************************************************/
{
	if(Interpolation==Quad)
	{
	/*	temp[0]=0.;
	    temp[1]=2.;
	    temp[2]=0.;
	    temp[3]=0.;
	    temp[4]=0.;
	    temp[5]=0.;*/
		
	temp[0]=ddPhi1Phi2_yy(xyz);
	temp[1]=ddPhi1Phi3_yy(xyz);
	temp[2]=ddPhi1Phi4_yy(xyz);
	temp[3]=ddPhi2Phi3_yy(xyz);
	temp[4]=ddPhi2Phi4_yy(xyz);
	temp[5]=ddPhi3Phi4_yy(xyz);  
	}
}
/**************************************************************************/
void  DDCubicRow_zz(real x, real y, real z, real xyz[], double temp[])
/**************************************************************************/
{
	if(Interpolation==Quad)
	{
	    temp[0]=ddPhi1Phi2_zz(xyz);
	    temp[1]=ddPhi1Phi3_zz(xyz);
	    temp[2]=ddPhi1Phi4_zz(xyz);
	    temp[3]=ddPhi2Phi3_zz(xyz);
	    temp[4]=ddPhi2Phi4_zz(xyz);
	    temp[5]=ddPhi3Phi4_zz(xyz);
	}
}
/**************************************************************************/
void  DDCubicRow_xy(real x, real y, real z, real xyz[], double temp[])
/**************************************************************************/
{
	if(Interpolation==Quad)
	{		
	    temp[0]=ddPhi1Phi2_xy(xyz);
	    temp[1]=ddPhi1Phi3_xy(xyz);
	    temp[2]=ddPhi1Phi4_xy(xyz);
	    temp[3]=ddPhi2Phi3_xy(xyz);
	    temp[4]=ddPhi2Phi4_xy(xyz);
	    temp[5]=ddPhi3Phi4_xy(xyz); 
	}
	else if(Interpolation==Cubic)
	{
		temp[0]=0.;
	    temp[1]=0.;
	    temp[2]=0.;
	    temp[3]=2.*x;
	    temp[4]=0.;
	    temp[5]=2.*y;
		temp[6]=0.;

        temp[7]=0.;
		temp[8]=0.;
		temp[9]=0.;
	    temp[10]=0.;
	    temp[11]=0.;
	    temp[12]=1.;
	    temp[13]=0.;
	    temp[14]=0.;
		temp[15]=z;
	}
}
/**************************************************************************/
void  DDCubicRow_xz(real x, real y, real z, real xyz[], double temp[])
/**************************************************************************/
{
	if(Interpolation==Quad)
	{		
	    temp[0]=ddPhi1Phi2_xz(xyz);
	    temp[1]=ddPhi1Phi3_xz(xyz);
	    temp[2]=ddPhi1Phi4_xz(xyz);
	    temp[3]=ddPhi2Phi3_xz(xyz);
	    temp[4]=ddPhi2Phi4_xz(xyz);
	    temp[5]=ddPhi3Phi4_xz(xyz); 
	}
}
/**************************************************************************/
void  DDCubicRow_yz(real x, real y, real z, real xyz[], double temp[])
/**************************************************************************/
{
	if(Interpolation==Quad)
	{	
	    temp[0]=ddPhi1Phi2_yz(xyz);
	    temp[1]=ddPhi1Phi3_yz(xyz);
	    temp[2]=ddPhi1Phi4_yz(xyz);
	    temp[3]=ddPhi2Phi3_yz(xyz);
	    temp[4]=ddPhi2Phi4_yz(xyz);
	    temp[5]=ddPhi3Phi4_yz(xyz);  
	}
}
/**************************************************************************/
void CubicMatrix(real xyz[], int n, real xyz0[], double output[])
/**************************************************************************/
{
	real x,y,z, temp[16];
	int  i, j;
	for(i=0; i<n; i++)
	{	
		x=xyz[3*i];
		y=xyz[3*i+1];
		z=xyz[3*i+2];
		CubicRow(x,y,z,xyz0,temp);
		if(Interpolation==Quad)    
		{
			for(j=0; j<6; j++) output[6*i+j]=temp[j];
		}
		else if(Interpolation==Cubic)
		{
			for(j=0; j<16; j++) output[16*i+j]=temp[j];
		}
	}
}
/**************************************************************************/
void Transpose(double Mat[],int m, int n, double output[])
/**************************************************************************/
{
	int  i,j;
	for(i=0; i<m; i++)
	{
		for(j=0; j<n; j++)
		{
			output[m*j+i]=Mat[n*i+j];
		}
	}
}
/**************************************************************************/
void Wvector(real xyz_nb[], real phi_nb[],int n, real xyz_t[], real phi_t[], double output[], int vec)
/**************************************************************************/
{
	real x,y,z;
	int i,j, LenVar;

	double *phi_linear;
 
	if(vec) LenVar=3;
	else    LenVar=1;

	phi_linear=new double[LenVar];

	for(i=0; i<n; i++)
	{
		x=xyz_nb[3*i];
		y=xyz_nb[3*i+1];
		z=xyz_nb[3*i+2];
		LinearQ(x,y,z, xyz_t, phi_t, phi_linear,vec);
	
		for(j=0; j<LenVar; j++)
		{
			if(LenVar==1)    output[j*n+i]=phi_nb[LenVar*i+j] - phi_linear[j];  
			else             output[j*n+i]=phi_nb[LenVar*i+j] - phi_linear[j];    
		}
	}
	delete phi_linear;
}

/**************************************************************************/
void Ccenter(int i, double result[])
/**************************************************************************/
{
	int    j,k, m,len;
	double  output[3];

    
   	for(k=0; k<3; k++)   output[k]=0.;
	len=CPIT(i);
	for(j=1; j<=len; j++)
	{
		m=cellJ(i,j);
		for(k=0; k<3; k++)
		{
		   output[k]=output[k] + vertex(m,k+1);
		}
	}
	for(k=0; k<3; k++)
	{
		result[k]=output[k]/len;
	}
}

/**************************************************************************/
double Distance(double v1[], double v2[])
/**************************************************************************/
{
	double x1,x2,y1,y2,z1,z2;
	x1=v1[0]; y1=v1[1]; z1=v1[2];
	x2=v2[0]; y2=v2[1]; z2=v2[2];
	return (sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2) + (z1 - z2)*(z1 - z2)));
}
/**************************************************************************/
void Bcenter(int i, double  result[])
/**************************************************************************/
{
	int    j,k,m,B_len;
    double output[3];

	B_len=Bound_Length(i);

	for(k=0; k<3; k++)  output[k]=0.;
	for(j=1; j<=B_len; j++)
	{
		m=BoundJ(i,j);
		if(m!=-1)
		{
			for(k=0; k<3; k++)
		    {
				output[k]=output[k]+vertex(m,k+1);
		    }
		}
	}
	if(B_len>3)
	{
		for(k=0; k<3; k++) result[k] = 0.25* output[k];
	}
	else
	{
		for(k=0; k<3; k++) result[k] = output[k]/3.;
	}

}
/**************************************************************************/
int ConnectTetandTet(int c)
/**************************************************************************/
{
	int result;
	result=c+1;
	return result;
}
/**************************************************************************/
int ConnectTetandPiramid(int c)
/**************************************************************************/
{
	int c1;
	c1=c+2;
	return c1;
}
/**************************************************************************/
int ConnectTetandPrism(int c)
/**************************************************************************/
{
	int c1;
	c1=c+3;
	return c1;
}
/**************************************************************************/
int ConnectPiramidandTet(int c)
/**************************************************************************/
{
	int c1;
	c1=c+2;
	return c1;
}
/**************************************************************************/
int ConnectPiramidandPiramid(int i,int j, int c)
/**************************************************************************/
{
	int c1;
	AA(i,j);
	if(Vlist(3)==Vlist(4))  c1=c+2;
    else                    c1=c+1;
	return c1;
}
/**************************************************************************/
int ConnectPiramidandPrism(int i,int j, int c)
/**************************************************************************/
{
	int c1;
	AA(i,j);
	if(Vlist(3)==Vlist(4))  c1=c+3;
    else                    c1=c+2;
	return c1;
}
/**************************************************************************/
int ConnectPrismandTet(int c)
/**************************************************************************/
{
	int c1;
	c1=c+1;
	return c1;
}
/**************************************************************************/
int ConnectPrismandPiramid(int i,int j, int c)
/**************************************************************************/
{
	int c1;
	AA(i,j);
	if(Vlist(3)==Vlist(4))  c1=c+2;
    else                    c1=c+1;
	return c1;
}
/**************************************************************************/
int ConnectPrismandPrism(int i,int j, int c)
/**************************************************************************/
{
	int c1;
	AA(i,j);
	if(Vlist(3)==Vlist(4))  c1=c+3;
    else                    c1=c+2;
	return c1;
}
/**************************************************************************/
int ConnectTetandAny(int i,int cb, int c)
/**************************************************************************/
{
	int c1,l,cbb;
	c1=c;
	for(l=1; l<=6; l++)
	{
		cbb=cboundJ(cb,l);
		if(cbb>0 && cbb!=i)
		{
			if(CPIT(cbb)==4)          
			{
				c1=ConnectTetandTet(c1);
				if(HI) 
					c1=ConnectTetandAny2(cb,cbb,c1);
			}
		    else if(CPIT(cbb)==5)     
			{
				c1=ConnectTetandPiramid(c1);
				if(HI) 
					c1=ConnectPiramidandAny(cb,cbb,c1);
			}
		    else if(CPIT(cbb)==6)     
			{
				c1=ConnectTetandPrism(c1);
				if(HI) 
					c1=ConnectPrismandAny2(cb,cbb,c1);
			}
		}
	}
	return c1;
}
/**************************************************************************/
int ConnectTetandAny2(int i,int cb, int c)
/**************************************************************************/
{
	int c1,l,cbb;

	c1=c;
	for(l=1; l<=6; l++)
	{
		cbb=cboundJ(cb,l);
		if(cbb>0 && cbb!=i)
		{
			if(CPIT(cbb)==4)          c1=ConnectTetandTet(c1);
		    else if(CPIT(cbb)==5)     c1=ConnectTetandPiramid(c1); 
		    else if(CPIT(cbb)==6)     c1=ConnectTetandPrism(c1);
		}
	}
	return c1;
}
/**************************************************************************/
int ConnectPiramidandAny(int i,int cb,int c)
/**************************************************************************/
{
	int c1,l,cbb;

	c1=c;
	for(l=1; l<=6; l++)
	{
		cbb=cboundJ(cb,l);
		if(cbb>0 && cbb!=i)
		{
			if(CPIT(cbb)==4)         
			{
				c1=ConnectPiramidandTet(c1);
				if(HI) c1=ConnectTetandAny2(cb,cbb,c1);
			}
			else if(CPIT(cbb)==5)    
			{
				c1=ConnectPiramidandPiramid(cb,l,c1); 
				if(HI) c1=ConnectPiramidandAny(cb,cbb,c1);
			}
		    else                      
			{
				c1=ConnectPiramidandPrism(cb,l,c1);
				if(HI) c1=ConnectPrismandAny2(cb,cbb,c1);
			}
		}
	}
	return c1;
}
/**************************************************************************/
int ConnectPiramidandAny2(int i,int cb,int c)
/**************************************************************************/
{
	int c1,l,cbb;

	c1=c;
	for(l=1; l<=6; l++)
	{
		cbb=cboundJ(cb,l);
		if(cbb>0 && cbb!=i)
		{
			if(CPIT(cbb)==4)         c1=ConnectPiramidandTet(c1);
			else if(CPIT(cbb)==5)    c1=ConnectPiramidandPiramid(cb,l,c1); 
		    else                      c1=ConnectPiramidandPrism(cb,l,c1);
		}
	}
	return c1;
}
/**************************************************************************/
int ConnectPrismandAny(int i,int cb, int c)
/**************************************************************************/
{
	int c1,l,cbb;

	c1=c;
	for(l=1; l<=6; l++)
	{
		cbb=cboundJ(cb,l);
		if(cbb>0 && cbb!=i)
		{
			if(CPIT(cbb)==4)         
			{
				c1=ConnectPrismandTet(c1);
				if(HI) c1=ConnectTetandAny2(cb,cbb,c1);
			}
			else if(CPIT(cbb)==5)    
			{
				c1=ConnectPrismandPiramid(cb,l,c1); 
				if(HI) c1=ConnectPiramidandAny(cb,cbb,c1);
			}
		    else                      
			{
				c1=ConnectPrismandPrism(cb,l,c1);
				if(HI) c1=ConnectPrismandAny2(cb,cbb,c1);
			}
		}
	}
	return c1;
}
/**************************************************************************/
int ConnectPrismandAny2(int i,int cb, int c)
/**************************************************************************/
{
	int c1,l,cbb;

	c1=c;
	for(l=1; l<=6; l++)
	{
		cbb=cboundJ(cb,l);
		if(cbb>0 && cbb!=i)
		{
			if(CPIT(cbb)==4)         c1=ConnectPrismandTet(c1);
			else if(CPIT(cbb)==5)    c1=ConnectPrismandPiramid(cb,l,c1); 
		    else                      c1=ConnectPrismandPrism(cb,l,c1);
		}
	}
	return c1;
}
/**************************************************************************/
int CountNeighborVertex(int i, int c)
/**************************************************************************/
{
	int cb, c1, j;
	
    c1=c;
    if(CPIT(i)==4)
	{
		for(j=1;j<=6;j++)
		{
			cb=cboundJ(i,j);
			if(cb>0)
			{
				if(CPIT(cb)==4)  
				{
					c1=ConnectTetandTet(c1);
					c1=ConnectTetandAny(i,cb,c1);
				}
				else if(CPIT(cb)==5)
				{
					c1=ConnectTetandPiramid(c1); 
					c1=ConnectPiramidandAny(i,cb,c1);
				}
				else if(CPIT(cb)==6)            
				{
					c1=ConnectTetandPrism(c1);
					c1=ConnectPrismandAny(i,cb,c1);
				}
			}
		}
	}
	else if(CPIT(i)==5)
	{
		for(j=1;j<=6;j++)
		{
			cb=cboundJ(i,j);
			if(cb>0)
			{
				if(CPIT(cb)==4)  
				{
					c1=ConnectPiramidandTet(c1);
					c1=ConnectTetandAny(i,cb,c1);
				}
				else if(CPIT(cb)==5)
				{
					c1=ConnectPiramidandPiramid(cb,j,c1);
					c1=ConnectPiramidandAny(i,cb,c1);
				}
				else if(CPIT(cb)==6)            
				{
					c1=ConnectPiramidandPrism(cb,j,c1);  
					c1=ConnectPrismandAny(i,cb,c1);
				}
			}
		}
	}
	else if(CPIT(i)==6) 
	{
		for(j=1;j<=6;j++)
		{
			cb=cboundJ(i,j);
			if(cb>0)
			{
				if(CPIT(cb)==4)  
				{
					c1=ConnectPrismandTet(c1);
					c1=ConnectTetandAny(i,cb,c1);
				}
				else if(CPIT(cb)==5)
				{
					c1=ConnectPrismandPiramid(cb,j,c1);
					c1=ConnectPiramidandAny(i,cb,c1);
				}
				else if(CPIT(cb)==6)             
				{
					c1=ConnectPrismandPrism(cb,j,c1);  
					c1=ConnectPrismandAny(i,cb,c1);
				}
			}
		}
	}
	return c1;
}

/**************************************************************************/
void  whichTetra(int i, double t, int ww)
/**************************************************************************/
{
	int   m[8];
	int  t1, t2, vo1, vo2, vo3, cb, cbb, cbbb, c1,c2;
	int  j, l, mm, k, n,kk, ll, kkk;
	int   m2[8], tempv;
	int  len1;
    vector<unsigned int> numbers;
	
    
	c1=0;
	
	if(Mesh==Tetra)
	{	
		c1=CountNeighborVertex(i,c1);
	}

	else
	{
		for(j=1; j<=6; j++)
	    {
			cb=cboundJ(i,j);
		    if (cb > 0)  c1=c1+1;
		}
	}
	
		
	if(Mesh==Tetra)
	{
		if(CPIT(i)==4)           n=c1;
		else if(CPIT(i)==5)      n=c1+1;
		else if(CPIT(i)==6)      n=c1+2;
	}
	else                  n=4*(c1+1);

	mm=(int)(RoundOff(t/TimeStep)); 
	k=(int)(RoundOff(mm%MXT));
	if (k==0) k=MXT;
	

	for(j=1; j<=CPIT(i); j++)
	{
	
		m[j-1]=cellJ(i,j);

	}

	if(Mesh==Tetra)
	{
		           c1=-1;
	}
	else           c1=3;
	for(j=0; j<4; j++)
	{
		if(CPIT(i)==4)       t1=cpit4[0][j];
		else if(CPIT(i)==5)	 t1=cpit5[ww][j];
		else if(CPIT(i)==6)	 t1=cpit6[ww][j];
			vo1=m[t1-1];
            tetra_xyz(j,0)=vertexX(vo1);
            tetra_xyz(j,1)=vertexY(vo1);
			tetra_xyz(j,2)=vertexZ(vo1);
			tetra_uvw(j,0)=verU(k,vo1);
			tetra_uvw(j,1)=verV(k,vo1);
			tetra_uvw(j,2)=verW(k,vo1); 
		   	tetra_t(j)=verT(k,vo1); 

            if(Mesh==Tetra)   
			{
				if(CPIT(i)==5 && j==0)
				{
					
					t2=ocpi5[ww][j];
				
			        vo2=m[t2-1]; // vertex order 1th, 2th,....  -> 1001, 1002,... 
				    c1=c1+1;
			        nb_xyz(c1,0)=vertexX(vo2);
			        nb_xyz(c1,1)=vertexY(vo2);
			        nb_xyz(c1,2)=vertexZ(vo2);
			        nb_uvw(c1,0)=verU(k,vo2);
			        nb_uvw(c1,1)=verV(k,vo2);
			        nb_uvw(c1,2)=verW(k,vo2);
			        nb_t(c1)=verT(k,vo2); 
				}
				else if(CPIT(i)==6 && j<=1)
				{
					
					t2=ocpi6[ww][j];
				
			        vo2=m[t2-1]; // vertex order 1th, 2th,....  -> 1001, 1002,... 
				    c1=c1+1;
			        nb_xyz(c1,0)=vertexX(vo2);
			        nb_xyz(c1,1)=vertexY(vo2);
			        nb_xyz(c1,2)=vertexZ(vo2);
			        nb_uvw(c1,0)=verU(k,vo2);
			        nb_uvw(c1,1)=verV(k,vo2);
			        nb_uvw(c1,2)=verW(k,vo2);
			        nb_t(c1)=verT(k,vo2); 

			        if(Magnet)
			        {
			//			nb_Fm(c1,0)=magFx(vo2);
			//	        nb_Fm(c1,1)=magFy(vo2);
			//	        nb_Fm(c1,2)=magFz(vo2);
			        }
				}
			}
	}
  

	c2=0;
	for(j=1; j<=6; j++)
	{
		cb=cboundJ(i,j);
		if (cb > 0)   
		{
			if(Mesh==Tetra)
			{
				//c2=0;
				if(CPIT(cb)==4)   
				{
					tempv=SubtractSet(&cellJ(cb,1),cb,&cellJ(i,1),i);
					if(c2==0)
					{
						c2=c2+1;
						numbers.push_back(tempv);
					}
					else
					{
						for(kkk=1; kkk<=c2; kkk++)
					    {
							if(tempv==Vlist(kkk))     break;
						    if(tempv!=Vlist(kkk) && kkk==c2)      
						    {
								c2=c2+1;
								numbers.push_back(tempv);
							    break;
							}
						}
					}
				}
				else if(CPIT(cb)==5 || CPIT(cb)==6)
				{
					SubtractSet3(&cellJ(cb,1),cb,&cellJ(i,1),i,&m2[0]);
					for(kk=0; kk<CPIT(cb); kk++)
					{
						if(m2[kk]!=0)    
						{
							if(c2==0)
					        {
								c2=c2+1;
								numbers.push_back(m2[kk]);
							}
							else
							{
							    for(kkk=1; kkk<=c2; kkk++)
					            {
								    if(m2[kk]==Vlist(kkk))     break;
								    if(m2[kk]!=Vlist(kkk) && kkk==c2)      
						            {
							            c2=c2+1;
										numbers.push_back(m2[kk]);
									    break;
									}
								}
							}
						}
						else    break;
					}

				}
			
				
				for(l=1; l<=6; l++)
				{
					cbb=cboundJ(cb,l);
					
					if(cbb>0 && cbb!=i)
					{
						
						if(CPIT(cbb)==4)     
						{
							tempv=SubtractSet(&cellJ(cbb,1),cbb,&cellJ(cb,1),cb);
							for(kkk=1; kkk<=c2; kkk++)
							{
								if(tempv==Vlist(kkk))     break;
								if(tempv!=Vlist(kkk) && kkk==c2)       
								{
									c2=c2+1;
									numbers.push_back(tempv);
									break;
								}
							}
						}
						else if(CPIT(cbb)==5 || CPIT(cbb)==6)
						{
							SubtractSet3(&cellJ(cbb,1),cbb,&cellJ(cb,1),cb,&m2[0]); 
							for(kk=0; kk<CPIT(cbb); kk++)
							{
								if(m2[kk]!=0)    
						        {
									for(kkk=1; kkk<=c2; kkk++)
					                {
										if(m2[kk]==Vlist(kkk))     break;
								        if(m2[kk]!=Vlist(kkk) && kkk==c2)      
						                {
							                c2=c2+1;
											numbers.push_back(m2[kk]);
									        break;
								        }
									}
						        }
						        else    break;
							}
						}
						if(HI)  {
						for(ll=1; ll<=6; ll++)
						{
							cbbb=cboundJ(cbb,ll);
							if(cbbb>0 && cbbb!=cb)
					        {
								if(CPIT(cbbb)==4)
								{
									tempv=SubtractSet(&cellJ(cbbb,1),cbbb,&cellJ(cbb,1),cbb);
					
						            for(kkk=1; kkk<=c2; kkk++)
					                {
							            if(tempv==Vlist(kkk))     break;
						                if(tempv!=Vlist(kkk) && kkk==c2)      
						                {
								            c2=c2+1;
											numbers.push_back(tempv);
							                break;
										}
									}
						        }
								else if(CPIT(cbbb)==5 || CPIT(cbbb)==6)
						        {
							        SubtractSet3(&cellJ(cbbb,1),cbbb,&cellJ(cbb,1),cbb,&m2[0]); 
									for(kk=0; kk<CPIT(cbb); kk++)
							        {
								        if(m2[kk]!=0)    
						                {
									        for(kkk=1; kkk<=c2; kkk++)
					                        {
										        if(m2[kk]==Vlist(kkk))     break;
								                if(m2[kk]!=Vlist(kkk) && kkk==c2)      
						                        {
							                        c2=c2+1;
													numbers.push_back(m2[kk]);
									                break;
												}
									        }
						                 }
						                 else    break;
									}
						        }	
					         }
						}
						}
					}
				}   
			}
			else 
			{
				AA(cb, j);
			    for(l=0; l<4; l++)
			    {
					c1=c1 + 1;
				    vo3=Vlist(l+1);
				    nb_xyz(c1,0)=vertexX(vo3);
		    	    nb_xyz(c1,1)=vertexY(vo3);
		    	    nb_xyz(c1,2)=vertexZ(vo3);
		    	    nb_uvw(c1,0)=verU(k,vo3 );
		    	    nb_uvw(c1,1)=verV(k,vo3 );
		    	    nb_uvw(c1,2)=verW(k,vo3 );
					nb_t(c1)=verT(k,vo3);
			    }
			}
		}

	}

	sort( numbers.begin(), numbers.end() );
    numbers.erase( unique( numbers.begin(), numbers.end() ), numbers.end() );
	
    len1=numbers.size();

	for(l=0; l<len1; l++)
	{
		c1=c1 + 1;
		vo3=numbers[l];
		nb_xyz(c1,0)=vertexX(vo3);
		nb_xyz(c1,1)=vertexY(vo3);
		nb_xyz(c1,2)=vertexZ(vo3);
		nb_uvw(c1,0)=verU(k,vo3 );
		nb_uvw(c1,1)=verV(k,vo3 );
		nb_uvw(c1,2)=verW(k,vo3 );
		nb_t(c1)=verT(k,vo3); 
	}

	NBV=c1+1;
	numbers.clear();
		
}

/**************************************************************************/
void  whichTetra_v2(int i, double xyz0[], double t,int ww)
/**************************************************************************/
{
	int   m[8];
	int   vo1, vo2,vo3, cb, cbb, cbbb, c1,c2;
	int  j, l, mm, k,kk, ll, kkk;
	int   m2[8], tempv;
	int  len1;
	int index2,t1,t2;
	int nv_VC;
	double *xyz1,Sum1,Sum2,dd;
	double *Id2;
    vector<unsigned int> numbers;
	vector<unsigned int> numbers2;
	vector<double> dist1;
	vector<double> dist2;
	vector<unsigned int> tetra_vertex_;
	vector<double>::iterator smallest1;
	xyz1=new double[3];
	mm=(int)(RoundOff(t/TimeStep)); 
	k=(int)(RoundOff(mm%MXT));
	if (k==0) k=MXT;

	for(j=1; j<=CPIT(i); j++)
	{
		m[j-1]=cellJ(i,j);
	}
	if(data_type==Vertex_f && ( Interpolation==Quad || Interpolation==Cubic || Interpolation==Linear))
	{
		for(j=0; j<4; j++)
	    {
		if(CPIT(i)==4)       t1=cpit4[0][j];
		else if(CPIT(i)==5)	 t1=cpit5[ww][j];
		else if(CPIT(i)==6)	 t1=cpit6[ww][j];
		vo1=m[t1-1];
		tetra_vertex_.push_back(vo1);

   
            if(Mesh==Tetra)   
			{
				if(CPIT(i)==5 && j==0)
				{			
					t2=ocpi5[ww][j];		
			        vo2=m[t2-1]; // vertex order 1th, 2th,....  -> 1001, 1002,...
			        numbers.push_back(vo2);
				}
				else if(CPIT(i)==6 && j<=1)
				{			
					t2=ocpi6[ww][j];
			        vo2=m[t2-1]; // vertex order 1th, 2th,....  -> 1001, 1002,... 
				    numbers.push_back(vo2);
				}
			}
			else   
			{
				t2=other[ww][j];
			    vo2=m[t2-1]; // vertex order 1th, 2th,....  -> 1001, 1002,... 	
				numbers.push_back(vo2);
			}		
		
		}
	}
	else if(Interpolation==InverseD)
	{
		for(j=1; j<=CPIT(i); j++)
	    {	
		    numbers.push_back(m[j-1]);
	    }
		if(data_type==Cell_f)
	    {
			len1=numbers.size();
	        dist1.resize(len1);
		    for(j=1; j<=len1; j++) 
	        {
			    for(l=1; l<=3; l++)  xyz1[l-1]=vertex(numbers[j-1],l);
			    dist1[j-1]=Distance(xyz0,xyz1);
		    }
		    smallest1 = min_element( dist1.begin(), dist1.end() );
	        index2=smallest1-dist1.begin();

			

	        nv_VC=numbers[index2];

			
			len1=VcCount(nv_VC);
			
            numbers.clear();
	        dist1.clear();
			for(j=1; j<=len1; j++) 
	        {			
			    numbers.push_back(VToCJ(nv_VC,j));
			}

			sort( numbers.begin(), numbers.end() );
            numbers.erase( unique( numbers.begin(), numbers.end() ), numbers.end() );
	
            len1=numbers.size();

			if(len1 !=VcCount(nv_VC))
			{
				printf("check \n");
			}
			
		
			Sum1=0.;
			for(j=1; j<=len1; j++) 
	        {	
				
				for(l=1; l<=3; l++)  xyz1[l-1]=cellcenter(numbers[j-1],l);
			    dd=Distance(xyz0,xyz1);
					
				dist1.push_back(dd);
				Sum1+=dd;
			}
			Sum1=Sum1/len1;
			for(j=1; j<=len1; j++) 
	        {	
			        numbers2.push_back(numbers[j-1]);
			        dist2.push_back(dist1[j-1]);		
			} 
            len1=numbers2.size();
			w=new double[len1];
	        Id2=new double[len1];
			Sum2=0.;
			for(j=1; j<=len1; j++)     w[j-1]=0.;
	        for(j=1; j<=len1; j++) 
	        {
				if(dist2[j-1]>=0. && dist2[j-1]<=1.0e-11 ) 
		        {
			        w[j-1]=1.;
			        goto lab2;
		        }
		        Id2[j-1]=1./pow(dist2[j-1],2.);
		        Sum2=Sum2+Id2[j-1];
		    }
		    for(j=1; j<=len1; j++)
	        {
		        w[j-1]=Id2[j-1]/Sum2;
	        }				
	    }
	}
    len1=numbers.size();  */
	if(Mesh==Tetra)
	{
		           c1=-1;
	}
	else           c1=3;
if(data_type==Vertex_f && Interpolation!=Linear)
{
	c2=0;
	for(j=1; j<=6; j++)
	{
		cb=cboundJ(i,j);
		if (cb > 0)   
		{
			if(Mesh==Tetra)
			{
				if(CPIT(cb)==4)   
				{
					tempv=SubtractSet(&cellJ(cb,1),cb,&cellJ(i,1),i);
					if(c2==0)
					{
						c2=c2+1;
						numbers.push_back(tempv);
					}
					else
					{
						for(kkk=1; kkk<=c2; kkk++)
					    {
							if(tempv==Vlist(kkk))     break;
						    if(tempv!=Vlist(kkk) && kkk==c2)      
						    {
								c2=c2+1;
								numbers.push_back(tempv);
							    break;
							}
						}
					}
				}
				else if(CPIT(cb)==5 || CPIT(cb)==6)
				{
					SubtractSet3(&cellJ(cb,1),cb,&cellJ(i,1),i,&m2[0]);
					for(kk=0; kk<CPIT(cb); kk++)
					{
						if(m2[kk]!=0)    
						{
							if(c2==0)
					        {
								c2=c2+1;
								numbers.push_back(m2[kk]);
							}
							else
							{
							    for(kkk=1; kkk<=c2; kkk++)
					            {
								    if(m2[kk]==Vlist(kkk))     break;
								    if(m2[kk]!=Vlist(kkk) && kkk==c2)      
						            {
							            c2=c2+1;
										numbers.push_back(m2[kk]);
									    break;
									}
								}
							}
						}
						else    break;
					}

				}
			
				
				for(l=1; l<=6; l++)
				{
					cbb=cboundJ(cb,l);
					
					if(cbb>0 && cbb!=i)
					{
						
						if(CPIT(cbb)==4)     
						{
							tempv=SubtractSet(&cellJ(cbb,1),cbb,&cellJ(cb,1),cb);
							for(kkk=1; kkk<=c2; kkk++)
							{
								if(tempv==Vlist(kkk))     break;
								if(tempv!=Vlist(kkk) && kkk==c2)       
								{
									c2=c2+1;
									numbers.push_back(tempv);
									break;
								}
							}
						}
						else if(CPIT(cbb)==5 || CPIT(cbb)==6)
						{
							SubtractSet3(&cellJ(cbb,1),cbb,&cellJ(cb,1),cb,&m2[0]); 
							for(kk=0; kk<CPIT(cbb); kk++)
							{
								if(m2[kk]!=0)    
						        {
									for(kkk=1; kkk<=c2; kkk++)
					                {
										if(m2[kk]==Vlist(kkk))     break;
								        if(m2[kk]!=Vlist(kkk) && kkk==c2)      
						                {
							                c2=c2+1;
											numbers.push_back(m2[kk]);
									        break;
								        }
									}
						        }
						        else    break;
							}
						}
						if(HI)  {
						for(ll=1; ll<=6; ll++)
						{
							cbbb=cboundJ(cbb,ll);
							if(cbbb>0 && cbbb!=cb)
					        {
								if(CPIT(cbbb)==4)
								{
									tempv=SubtractSet(&cellJ(cbbb,1),cbbb,&cellJ(cbb,1),cbb);
					
						            for(kkk=1; kkk<=c2; kkk++)
					                {
							            if(tempv==Vlist(kkk))     break;
						                if(tempv!=Vlist(kkk) && kkk==c2)      
						                {
								            c2=c2+1;
											numbers.push_back(tempv);
							                break;
										}
									}
						        }
								else if(CPIT(cbbb)==5 || CPIT(cbbb)==6)
						        {
							        SubtractSet3(&cellJ(cbbb,1),cbbb,&cellJ(cbb,1),cbb,&m2[0]); 
									for(kk=0; kk<CPIT(cbb); kk++)
							        {
								        if(m2[kk]!=0)    
						                {
									        for(kkk=1; kkk<=c2; kkk++)
					                        {
										        if(m2[kk]==Vlist(kkk))     break;
								                if(m2[kk]!=Vlist(kkk) && kkk==c2)      
						                        {
							                        c2=c2+1;
													numbers.push_back(m2[kk]);
									                break;
												}
									        }
						                 }
						                 else    break;
									}
						        }	
					         }
						}
						}
					}
				}   
			}
			else 
			{
				AA(cb, j);
			    for(l=0; l<4; l++)
			    {
					c1=c1 + 1;
				    vo3=Vlist(l+1);
				    nb_xyz(c1,0)=vertexX(vo3);
		    	    nb_xyz(c1,1)=vertexY(vo3);
		    	    nb_xyz(c1,2)=vertexZ(vo3);
		    	    nb_uvw(c1,0)=verU(k,vo3 );
		    	    nb_uvw(c1,1)=verV(k,vo3 );
		    	    nb_uvw(c1,2)=verW(k,vo3 );
					nb_t(c1)=verT(k,vo3);
			    }
			}
		}

	}

    len1=numbers.size();
	sort( numbers.begin(), numbers.end() );
    numbers.erase( unique( numbers.begin(), numbers.end() ), numbers.end() );
	
    len1=numbers.size();
	dist1.resize(len1);

	if(Interpolation==InverseD)
	{
		w=new double[len1];
	    Id2=new double[len1];
	}
	Sum1=0.;
	for(j=1; j<=len1; j++) 
	{
		if(Interpolation==InverseD)  w[j-1]=0.;
		for(l=1; l<=3; l++)  xyz1[l-1]=vertex(numbers[j-1],l);
		dist1[j-1]=Distance(xyz0,xyz1);
		Sum1+=dist1[j-1];
	}
	Sum1=Sum1/len1;
	for(j=1; j<=len1; j++) 
	{	
			numbers2.push_back(numbers[j-1]);
			dist2.push_back(dist1[j-1]);		
	} 

	len1=numbers2.size();
	if(Interpolation==InverseD)
	{
	    Sum2=0.;
	    for(j=1; j<=len1; j++) 
	    {
		    if(dist2[j-1]>=0. && dist2[j-1]<=1.0e-20 ) 
		    {
			    w[j-1]=1.;
			    goto lab;
		    }
		    Id2[j-1]=1./(dist2[j-1]*dist2[j-1]);
		    Sum2=Sum2+Id2[j-1];
		}
		for(j=1; j<=len1; j++)
	    {
		    w[j-1]=Id2[j-1]/Sum2;
	    }
	} 	

lab:
	
	numbers.clear();
	dist1.clear();
    len1=numbers2.size();  
}
	if(data_type==Vertex_f && (Interpolation==Quad || Interpolation==Cubic || Interpolation==Linear))
	{
		for(j=0; j<4; j++)
	    {
		vo1=tetra_vertex_[j];

		tetra_xyz(j,0)=vertexX(vo1);
        tetra_xyz(j,1)=vertexY(vo1);
	    tetra_xyz(j,2)=vertexZ(vo1);
		tetra_uvw(j,0)=verU(k,vo1);
		tetra_uvw(j,1)=verV(k,vo1);
		tetra_uvw(j,2)=verW(k,vo1); 
		tetra_t(j)=verT(k,vo1); 
		}

	}

if(data_type==Vertex_f && Interpolation!=Linear)
{

	for(j=0; j<len1; j++)
	{
		vo3=numbers2[j];

		nb_xyz(j,0)=vertexX(vo3);
		nb_xyz(j,1)=vertexY(vo3);
		nb_xyz(j,2)=vertexZ(vo3);
		nb_uvw(j,0)=verU(k,vo3 );
		nb_uvw(j,1)=verV(k,vo3 );
		nb_uvw(j,2)=verW(k,vo3 );
		nb_t(j)=verT(k,vo3); 
	}
	NBV=len1;
	numbers2.clear();
	dist2.clear();
	tetra_vertex_.clear();
	if(Interpolation==InverseD)
	{
		delete Id2;
	}
}

lab2:
	if(data_type==Cell_f && Interpolation==InverseD)
	{
		numbers.clear();
	    dist1.clear();
		for(j=0; j<len1; j++)
		{
			vo3=VToCJ(nv_VC,j+1);
			nb_xyz(j,0)= cellcenterX(vo3);
		    nb_xyz(j,1)= cellcenterY(vo3);
		    nb_xyz(j,2)= cellcenterZ(vo3);
			nb_uvw(j,0)=cellU(vo3 );
		    nb_uvw(j,1)=cellV(vo3 );
		    nb_uvw(j,2)=cellW(vo3 );
		    nb_t(j)=cellT(vo3); 
		}
		NBV=len1;
	    numbers2.clear();
	    dist2.clear();
		delete Id2;
	}
delete xyz1;		
}

/**************************************************************************/
void  whichTetra_v3(int icp, double xyz0[], int ww)
/**************************************************************************/
{
	int   m[8];
	int   vo1;
	int  j,t1;
	vector<unsigned int> tetra_vertex_;

	for(j=1; j<=CPIT(icp); j++)
	{
		m[j-1]=cellJ(icp,j);
	}
	for(j=0; j<4; j++)
    {
		    if(CPIT(icp)==4)       t1=cpit4[0][j];
		    else if(CPIT(icp)==5)	 t1=cpit5[ww][j];
		    else if(CPIT(icp)==6)	 t1=cpit6[ww][j];
		    vo1=m[t1-1];
		    tetra_vertex_.push_back(vo1);
	}
	for(j=0; j<4; j++)
    {
		vo1=tetra_vertex_[j];

		tetra_xyz(j,0)=vertexX(vo1);
        tetra_xyz(j,1)=vertexY(vo1);
	    tetra_xyz(j,2)=vertexZ(vo1);
	}
	tetra_vertex_.clear();	
}
/**************************************************************************/
void TetraDecomp(int i, double k, double plist[])
/**************************************************************************/
{
	int j,kk;
	int vlist[8], m[8], trilist[3];

	
	for(j=1; j<=CPIT(i); j++)
	{
		vlist[j-1]=cellJ(i,j);
		m[j-1]=vlist[j-1];
	}
	
    
	if(Mesh==Tetra) 
	{
		if(CPIT(i)==4)
		{
			whichTetra_v2(i,plist, k, 0);
            goto finish;

		}
		else if(CPIT(i)==5)
		{
			kk=0; 
			for(j=0; j<3; j++)
	        {
					trilist[j]=vlist[cpit5[kk][j]-1];
	        }
			if(TriPlane(trilist, plist) > 0 )
            {
					whichTetra_v2(i,plist, k,0);
                    goto finish;
			}
			

			whichTetra_v2(i,plist, k,1);
            goto finish;
			 
		}
		else if(CPIT(i)==6)
		{
			kk=0; 
			 
			for(j=0; j<3; j++)
	        {
					trilist[j]=vlist[cpit6[kk][j]-1];
	        }
			if(TriPlane(trilist, plist) > 0 )
	        {
					whichTetra_v2(i,plist, k,0);
                    goto finish;
			}
			else
			{
				    kk=1;
					
					for(j=0; j<3; j++)
	                {
						trilist[j]=vlist[cpit6[kk][j]-1];
	                }
					if(TriPlane(trilist, plist) > 0 )
					{
						whichTetra_v2(i,plist, k,1);
						goto finish;
					}
					else
					{
					  whichTetra_v2(i,plist, k,2);
                      goto finish;
					}

			}
				   
		}
		else
		{
			whichTetra_v2(i,plist, k,0);
            goto finish;

		}
	}

	else
	{
		for(kk=0; kk<4; kk++)
	    {
			for(j=0; j<3; j++)
	        {
				trilist[j]=vlist[tetra[kk][j]-1];
	        }
			if(TriPlane(trilist, plist) > 0 )
	        {
				whichTetra_v2(i,plist, k,0);
                goto finish;
			}
		}
		whichTetra_v2(i,plist, k,0);
        goto finish;

	}

finish:	
	;

} 

/**************************************************************************/
void ScatterInter(int i, double plist[], double nb_phi[], double tetra_phi[], double uvw_Inter[], int vec)
/**************************************************************************/
{
	int j,k, c1, n,cb,LenVar, Len1;

	double PhiPhi[16], Phi_Linear[3], WW[100];


    double  b[17], A[17];
	double wmax, wmin;
	

	c1=0;
	if(vec)    LenVar=3;
	else       LenVar=1;

	if(Interpolation==Cubic)              Len1=16;
	else if(Interpolation==Quad)          Len1=6;
	
	if(Mesh==Tetra)
	{	
		c1=CountNeighborVertex(i,c1);
	}

	else 
	{
		for(j=1; j<=6; j++)
	    {
			cb=cboundJ(i,j);
		    if (cb > 0)  c1=c1+1;
		}
	}
	
		
	if(Mesh==Tetra)
	{
		if(CPIT(i)==4)                      n=c1;
		else if(CPIT(i)==5)                 n=c1+1;
		else if(CPIT(i)==6)                 n=c1+2;
	}
	else                  n=4*(c1+1);
	n=NBV;
	if(n>=100) 
		printf("\n n is over 50\n");
   
	if(Interpolation==Linear)
	{
		LinearQ_tetra(plist[0],plist[1],plist[2],tetra_xyz_, tetra_phi, Phi_Linear,vec);
	}

	if(Interpolation==Quad || Interpolation==Cubic)
	{
	    CubicMatrix(nb_xyz_, n, tetra_xyz_, Cmat_);
	    Wvector(nb_xyz_, nb_phi, n, tetra_xyz_, tetra_phi, W_,vec);
       LinearQ(plist[0],plist[1],plist[2],tetra_xyz_, tetra_phi, Phi_Linear,vec);

        CubicRow(plist[0], plist[1], plist[2], tetra_xyz_, PhiPhi);
		
     
	    for(k=0; k<n; k++)
	    {
		    for(j=0; j<Len1; j++)  TCmat_[j*n+k]=Cmat_[Len1*k+j];          //	Transpose 
	    }


        MatMatProduct(TCCmat_,TCmat_, Cmat_, Len1, n, Len1);
	
	
	    for(k=0; k<LenVar; k++)
	    {
		    for(j=0; j<n; j++)  WW[j]=W_[k*n+j];  
	
		    MatVecProduct(TCW_, TCmat_, WW, Len1, n);
		    for(j=0; j<Len1; j++)		bQR_[Len1*k+j+1]=TCW_[j];   
	    }


	    for(k=0; k<Len1; k++)
	    {
		    for(j=0; j<Len1; j++)
		    {
			    uQR_[Len1*k+j+1]=TCCmat_[Len1*k+j];	
		    }
	    }


        svdcmp(uQR_,Len1,Len1,wQR_,vQR_);
	    wmax=0.0;
	    for(j=1; j<=Len1; j++) if (wQR(j) > wmax) wmax=wQR(j);
	    wmin = wmax*1.0e-6;
	    for(j=1; j<=Len1; j++) if (wQR(j) < wmin) wQR(j)=0.0;
	
	    for(k=1; k<=LenVar; k++)
	    {
		    for(j=1;j<=Len1; j++)  
		    {
			    b[j]=bQR_[Len1*(k-1)+j];  
		    	A[j]=AQR_[Len1*(k-1)+j];    
		    }
		    svbksb(uQR_,wQR_,vQR_,Len1,Len1,b,A);
		    for(j=1; j<=Len1; j++)  A0_[k-1][j-1]=A[j];
	    }
	}
	if(Interpolation==Linear)
	{
		for(j=0; j<LenVar; j++)   uvw_Inter[j]=Phi_Linear[j];
	}
	else if(Interpolation==Quad || Interpolation==Cubic)
	{
		for(j=0; j<LenVar; j++)   uvw_Inter[j]=Phi_Linear[j] + Dotn(A0_[j],PhiPhi,Len1);
	}
	else if(Interpolation==InverseD)
	{
		
		for(j=0; j<LenVar; j++)   
		{
			uvw_Inter[j]=0.;
			for(k=1; k<=n; k++)     uvw_Inter[j] += w[k-1]*nb_phi[LenVar*(k-1)+j];
		}
	}	

} 

/**************************************************************************/
void ScatterInter2(int i, double plist[], double nb_phi[], double tetra_phi[], double uvw_Inter[], double Duvw_InterDx[],double Duvw_InterDy[] ,double Duvw_InterDz[]
, double DDuvw_inter_xx[],double DDuvw_inter_yy[],double DDuvw_inter_zz[],double DDuvw_inter_xy[],double DDuvw_inter_xz[],double DDuvw_inter_yz[], int vec)
/**************************************************************************/
{
	int j,k, c1, n, LenVar, Len1;
	
	double PhiPhi[16], Phi_Linear[3], WW[100];
	double DPhiPhiDx[16], DPhi_LinearDx[3];
	double DPhiPhiDy[16], DPhi_LinearDy[3];
	double DPhiPhiDz[16], DPhi_LinearDz[3];

	double DDPhiPhi_xx[16],DDPhiPhi_yy[16],DDPhiPhi_zz[16],DDPhiPhi_xy[16],DDPhiPhi_xz[16],DDPhiPhi_yz[16];

	real   A[17];
	double b[17];
	double wmax, wmin;
	int cb;


    c1=0;

	if(vec)    LenVar=3;
	else       LenVar=1;

	if(Interpolation==Cubic)               Len1=16;
	else if(Interpolation==Quad)          Len1=6;

	
	if(Mesh==Tetra)
	{	
		c1=CountNeighborVertex(i,c1);
	}

	else
	{
		for(j=1; j<=6; j++)
	    {
			cb=cboundJ(i,j);
		    if (cb > 0)  c1=c1+1;
		}
	}
	
		
	if(Mesh==Tetra)
	{
		if(CPIT(i)==4)                      n=c1;
		else if(CPIT(i)==5)                 n=c1+1;
		else if(CPIT(i)==6)                 n=c1+2;
	}
	else                  n=4*(c1+1);

	n=NBV;

	if(Interpolation==Linear)
	{
		LinearQ_tetra(plist[0],plist[1],plist[2],tetra_xyz_, tetra_phi, Phi_Linear,vec);
	}
	
	if(Interpolation==Quad || Interpolation==Cubic)
	{
	 CubicMatrix(nb_xyz_, n, tetra_xyz_, Cmat_);
	 Wvector(nb_xyz_, nb_phi, n, tetra_xyz_,  tetra_phi, W_,vec);
	// LinearQ_tetra(plist[0],plist[1],plist[2],tetra_xyz_, tetra_phi, Phi_Linear,vec);
	 LinearQ(plist[0],plist[1],plist[2],tetra_xyz_, tetra_phi, Phi_Linear,vec);
	 DLinearQdx(tetra_xyz_,  tetra_phi, DPhi_LinearDx,vec);
	 DLinearQdy(tetra_xyz_,  tetra_phi, DPhi_LinearDy,vec);
	 DLinearQdz(tetra_xyz_,  tetra_phi, DPhi_LinearDz,vec);
	 CubicRow(plist[0], plist[1], plist[2], tetra_xyz_, PhiPhi);
	 DCubicRowDx(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDx);
	 DCubicRowDy(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDy);
	 DCubicRowDz(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDz);
	 DDCubicRow_xx(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xx);
	 DDCubicRow_yy(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_yy);
	 DDCubicRow_zz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_zz);
	 DDCubicRow_xy(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xy);
	 DDCubicRow_xz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xz);
	 DDCubicRow_yz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_yz);


	for(k=0; k<n; k++)
		for(j=0; j<Len1; j++)  TCmat_[j*n+k]=Cmat_[Len1*k+j]; 
	

    MatMatProduct(TCCmat_,TCmat_, Cmat_, Len1, n, Len1);
	for(k=0; k<LenVar; k++)
	{
		for(j=0; j<n; j++)  WW[j]=W_[k*n+j];
		MatVecProduct(TCW_, TCmat_, WW, Len1, n);
		for(j=0; j<Len1; j++)		bQR_[Len1*k+j+1]=TCW_[j];   
	}


	for(k=0; k<Len1; k++)
	{
		for(j=0; j<Len1; j++)
		{
			uQR_[Len1*k+j+1]=TCCmat_[Len1*k+j];			
		}
	}



    svdcmp(uQR_,Len1,Len1,wQR_,vQR_);
	wmax=0.0;
	for(j=1; j<=Len1; j++) if (wQR(j) > wmax) wmax=wQR(j);
	wmin = wmax*1.0e-6;
	for(j=1; j<=Len1; j++) if (wQR(j) < wmin) wQR(j)=0.0;
	

	

	for(k=1; k<=LenVar; k++)
	{
		for(j=1;j<=Len1; j++)  
		{
			b[j]=bQR_[Len1*(k-1)+j];  
			//A[j]=AQR_[Len1*(k-1)+j];   
		}
		svbksb(uQR_,wQR_,vQR_,Len1,Len1,b,A);
		for(j=1; j<=Len1; j++)  A0_[k-1][j-1]=A[j];
	}
	}

	if(Interpolation==Linear)
	{
		for(j=0; j<LenVar; j++)   uvw_Inter[j]=Phi_Linear[j];
	}
	else if(Interpolation==Quad || Interpolation==Cubic)
	{
		for(j=0; j<LenVar; j++)  
		{
			uvw_Inter[j]=Phi_Linear[j] + Dotn(A0_[j],PhiPhi,Len1);
			Duvw_InterDx[j]=DPhi_LinearDx[j]+ Dotn(A0_[j],DPhiPhiDx,Len1);
			Duvw_InterDy[j]=DPhi_LinearDy[j]+ Dotn(A0_[j],DPhiPhiDy,Len1);
			Duvw_InterDz[j]=DPhi_LinearDz[j]+ Dotn(A0_[j],DPhiPhiDz,Len1);
		    DDuvw_inter_xx[j]= Dotn(A0_[j],DDPhiPhi_xx,Len1);
			DDuvw_inter_yy[j]= Dotn(A0_[j],DDPhiPhi_yy,Len1);
			DDuvw_inter_zz[j]= Dotn(A0_[j],DDPhiPhi_zz,Len1);
			DDuvw_inter_xy[j]= Dotn(A0_[j],DDPhiPhi_xy,Len1);
			DDuvw_inter_xz[j]= Dotn(A0_[j],DDPhiPhi_xz,Len1);
			DDuvw_inter_yz[j]= Dotn(A0_[j],DDPhiPhi_yz,Len1);  
		}
	}
	else if(Interpolation==InverseD)
	{
		
		for(j=0; j<LenVar; j++)   
		{
			uvw_Inter[j]=0.;
			for(k=1; k<=n; k++)     uvw_Inter[j] += w[k-1]*nb_phi[LenVar*(k-1)+j];
		}
	}	  
} 

/**************************************************************************/
void TetraDecompInter(int i, double k, double plist[], double uvw_Inter[])
/**************************************************************************/
{
	int j,kk, c1, n;
	int vlist[8], m[8], trilist[3];

	double PhiPhi[6], Phi_Linear[3], WW[100];


    double  b[7], A[7];
	double wmax, wmin;
	

    c1=0;
	for(j=1; j<=6; j++)
	{
		if (cboundJ(i,j) > 0) c1=c1+1;
	}
	n=4*(c1+1);


	


/*	A=dmatrix(1,3,1,6);
	u=dmatrix(1,6,1,6);
	v=dmatrix(1,6,1,6);
	w=dvector(1,6); 
	b=dmatrix(1,3,1,6);   */


	for(j=1; j<=8; j++)
	{
		vlist[j-1]=cellJ(i,j);
		m[j-1]=vlist[j-1];
	}

	for(j=0; j<3; j++)
	{
			trilist[j]=vlist[tetra[0][j]-1];
	}
	if (TriPlane(trilist, plist) > 0 )
	{
        	whichTetra(i, k, 0);
		    CubicMatrix(nb_xyz_, n, tetra_xyz_, Cmat_);
            Wvector(nb_xyz_, nb_uvw_, n, tetra_xyz_, tetra_uvw_, W_,1);
			LinearQ(plist[0],plist[1],plist[2],tetra_xyz_, tetra_uvw_, Phi_Linear,1);
		
            CubicRow(plist[0], plist[1], plist[2], tetra_xyz_, PhiPhi);
		
            goto finish;
	

    //Interpolate in A;
	}
	else
	{
		for(j=0; j<3; j++)
		{
			trilist[j]=vlist[tetra[1][j]-1];
		}
		if (TriPlane(trilist, plist) > 0 )
		{
			whichTetra(i, k, 1);
		    CubicMatrix(nb_xyz_, n, tetra_xyz_, Cmat_);
            Wvector(nb_xyz_, nb_uvw_, n, tetra_xyz_, tetra_uvw_, W_,1);
			LinearQ(plist[0],plist[1],plist[2],tetra_xyz_, tetra_uvw_, Phi_Linear,1);
		
            CubicRow(plist[0], plist[1], plist[2], tetra_xyz_, PhiPhi);
		
            goto finish;
	


		//Interpolate in B;
		}
		else
		{
			for(j=0; j<3; j++)
			{
				trilist[j]=vlist[tetra[2][j]-1];
			}
			if (TriPlane(trilist, plist) > 0 ) 
			{
				whichTetra(i, k, 2);
		        CubicMatrix(nb_xyz_, n, tetra_xyz_, Cmat_);
                Wvector(nb_xyz_, nb_uvw_, n, tetra_xyz_, tetra_uvw_, W_,1);
		    	LinearQ(plist[0],plist[1],plist[2],tetra_xyz_, tetra_uvw_, Phi_Linear,1);
		
                CubicRow(plist[0], plist[1], plist[2], tetra_xyz_, PhiPhi);
		    

                goto finish;
			
				//Interpolate in c;
			}
			else
			{
				for(j=0; j<3; j++)
				{
					trilist[j]=vlist[tetra[3][j]-1];
				}
				if (TriPlane(trilist, plist) > 0 ) 
				{
				   whichTetra(i, k, 3);
		           CubicMatrix(nb_xyz_, n, tetra_xyz_, Cmat_);
                   Wvector(nb_xyz_, nb_uvw_, n, tetra_xyz_, tetra_uvw_, W_,1);
			       LinearQ(plist[0],plist[1],plist[2],tetra_xyz_, tetra_uvw_, Phi_Linear,1);
		
                   CubicRow(plist[0], plist[1], plist[2], tetra_xyz_, PhiPhi);
	          
                    goto finish;

			
				//Interpolate in D;
				}
				else 
				{
					whichTetra(i, k, 4);
		            CubicMatrix(nb_xyz_, n, tetra_xyz_, Cmat_);
                    Wvector(nb_xyz_, nb_uvw_, n, tetra_xyz_, tetra_uvw_, W_,1);
		         	LinearQ(plist[0],plist[1],plist[2],tetra_xyz_, tetra_uvw_, Phi_Linear,1);
		
                    CubicRow(plist[0], plist[1], plist[2], tetra_xyz_, PhiPhi);
	          
                
				//Interpolate in E;
				
				}
			}
		}
	} 
finish:
		for(kk=0; kk<n; kk++)
		for(j=0; j<6; j++)  TCmat_[j*n+kk]=Cmat(kk,j);

//	Transpose(Cmat_,n,6,TCmat);
    MatMatProduct(TCCmat_,TCmat_, Cmat_, 6, n, 6);
	
	for(kk=0; kk<3; kk++)
	{
		for(j=0; j<n; j++)  WW[j]=W_[kk*n+j];
		MatVecProduct(TCW_, TCmat_, WW, 6, n);
		for(j=0; j<6; j++)		bQR(kk+1,j+1)=TCW_[j];
	}


	for(kk=0; kk<6; kk++)
	{
		for(j=0; j<6; j++)
		{
			uQR(kk+1,j+1)=TCCmat(kk,j);
		
		}
	}


    svdcmp(uQR_,6,6,wQR_,vQR_);
	wmax=0.0;
	for(j=1; j<=6; j++) if (wQR(j) > wmax) wmax=wQR(j);
	wmin = wmax*1.0e-6;
	for(j=1; j<=6; j++) if (wQR(j) < wmin) wQR(j)=0.0;
	
	for(kk=1; kk<=3; kk++)
	{
		for(j=1;j<=6; j++)  
		{
			b[j]=bQR(kk,j);
			A[j]=AQR(kk,j);    }
		svbksb(uQR_,wQR_,vQR_,6,6,b,A);
		for(j=1; j<=6; j++)  A0_[kk-1][j-1]=A[j];
	}

	

		
		
        for(j=0; j<3; j++)
		{

		    uvw_Inter[j]=Phi_Linear[j]  + Dotn(A0_[j],PhiPhi,6);
	
		}
	
  

/*
	free_dmatrix(A,1,3,1,6);
	free_dmatrix(u,1,6,1,6);
	free_dmatrix(v,1,6,1,6);
	free_dvector(w,1,6);
	free_dvector(b,1,3,1,6);  */





} 

/**************************************************************************/
void TetraDecompInter2(int i, double k, double plist[], double uvw_Inter[], double Duvw_InterDx[],double Duvw_InterDy[] ,double Duvw_InterDz[])
/**************************************************************************/
{
	int j,kk, c1, n;
	int vlist[8], m[8], trilist[3];

	double PhiPhi[6], Phi_Linear[3], WW[28];
	double DPhiPhiDx[6], DPhi_LinearDx[3];
	double DPhiPhiDy[6], DPhi_LinearDy[3];
	double DPhiPhiDz[6], DPhi_LinearDz[3];
	double DDPhiPhi_xx[6],DDPhiPhi_yy[6],DDPhiPhi_zz[6],DDPhiPhi_xy[6],DDPhiPhi_xz[6],DDPhiPhi_yz[6];

	real   A[7];
	double b[7];
	double wmax, wmin;


    c1=0;
	for(j=1; j<=6; j++)
	{
		if (cboundJ(i,j) > 0) c1=c1+1;
	}
	n=4*(c1+1);
	for(j=1; j<=8; j++)
	{
		vlist[j-1]=cellJ(i,j);
		m[j-1]=vlist[j-1];
	}

	for(j=0; j<3; j++)
	{
			trilist[j]=vlist[tetra[0][j]-1];
	}
	if (TriPlane(trilist, plist) > 0 )
	{
        	whichTetra(i, k, 0);
		    CubicMatrix(nb_xyz_, n, tetra_xyz_, Cmat_);
            Wvector(nb_xyz_, nb_uvw_, n, tetra_xyz_, tetra_uvw_, W_,1);
			LinearQ_tetra(plist[0],plist[1],plist[2],tetra_xyz_, tetra_uvw_, Phi_Linear,1);
			DLinearQdx(tetra_xyz_, tetra_uvw_, DPhi_LinearDx,1);
			DLinearQdy(tetra_xyz_, tetra_uvw_, DPhi_LinearDy,1);
			DLinearQdz(tetra_xyz_, tetra_uvw_, DPhi_LinearDz,1);
            CubicRow(plist[0], plist[1], plist[2], tetra_xyz_, PhiPhi);
			DCubicRowDx(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDx);
			DCubicRowDy(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDy);
			DCubicRowDz(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDz);
			DDCubicRow_xx(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xx);
	        DDCubicRow_yy(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_yy);
	        DDCubicRow_zz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_zz);
	        DDCubicRow_xy(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xy);
	        DDCubicRow_xz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xz);
	        DDCubicRow_yz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_yz);
            goto finish;
    //Interpolate in A;
	}
	else
	{
		for(j=0; j<3; j++)
		{
			trilist[j]=vlist[tetra[1][j]-1];
		}
		if (TriPlane(trilist, plist) > 0 )
		{
			whichTetra(i, k, 1);
		    CubicMatrix(nb_xyz_, n, tetra_xyz_, Cmat_);
            Wvector(nb_xyz_, nb_uvw_, n, tetra_xyz_, tetra_uvw_, W_,1);
			LinearQ(plist[0],plist[1],plist[2],tetra_xyz_, tetra_uvw_, Phi_Linear,1);
			DLinearQdx(tetra_xyz_, tetra_uvw_, DPhi_LinearDx,1);
			DLinearQdy(tetra_xyz_, tetra_uvw_, DPhi_LinearDy,1);
			DLinearQdz(tetra_xyz_, tetra_uvw_, DPhi_LinearDz,1);
            CubicRow(plist[0], plist[1], plist[2], tetra_xyz_, PhiPhi);
			DCubicRowDx(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDx);
			DCubicRowDy(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDy);
			DCubicRowDz(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDz);
			DDCubicRow_xx(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xx);
	        DDCubicRow_yy(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_yy);
	        DDCubicRow_zz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_zz);
	        DDCubicRow_xy(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xy);
	        DDCubicRow_xz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xz);
	        DDCubicRow_yz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_yz); 
            goto finish;
		//Interpolate in B;
		}
		else
		{
			for(j=0; j<3; j++)
			{
				trilist[j]=vlist[tetra[2][j]-1];
			}
			if (TriPlane(trilist, plist) > 0 ) 
			{
				whichTetra(i, k, 2);
		        CubicMatrix(nb_xyz_, n, tetra_xyz_, Cmat_);
                Wvector(nb_xyz_, nb_uvw_, n, tetra_xyz_, tetra_uvw_, W_,1);
		      	LinearQ(plist[0],plist[1],plist[2],tetra_xyz_, tetra_uvw_, Phi_Linear,1);
			    DLinearQdx(tetra_xyz_, tetra_uvw_, DPhi_LinearDx,1);
			    DLinearQdy(tetra_xyz_, tetra_uvw_, DPhi_LinearDy,1);
    			DLinearQdz(tetra_xyz_, tetra_uvw_, DPhi_LinearDz,1);
                CubicRow(plist[0], plist[1], plist[2], tetra_xyz_, PhiPhi);
	    		DCubicRowDx(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDx);
	    		DCubicRowDy(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDy);
		    	DCubicRowDz(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDz);

				DDCubicRow_xx(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xx);
	            DDCubicRow_yy(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_yy);
	            DDCubicRow_zz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_zz);
	            DDCubicRow_xy(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xy);
	            DDCubicRow_xz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xz);
	            DDCubicRow_yz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_yz);  


                goto finish;
			
				//Interpolate in c;
			}
			else
			{
				for(j=0; j<3; j++)
				{
					trilist[j]=vlist[tetra[3][j]-1];
				}
				if (TriPlane(trilist, plist) > 0 ) 
				{
					whichTetra(i, k, 3);
		            CubicMatrix(nb_xyz_, n, tetra_xyz_, Cmat_);
                    Wvector(nb_xyz_, nb_uvw_, n, tetra_xyz_, tetra_uvw_, W_,1);
		        	LinearQ(plist[0],plist[1],plist[2],tetra_xyz_, tetra_uvw_, Phi_Linear,1);
		        	DLinearQdx(tetra_xyz_, tetra_uvw_, DPhi_LinearDx,1);
	        		DLinearQdy(tetra_xyz_, tetra_uvw_, DPhi_LinearDy,1);
	        		DLinearQdz(tetra_xyz_, tetra_uvw_, DPhi_LinearDz,1);
                    CubicRow(plist[0], plist[1], plist[2], tetra_xyz_, PhiPhi);
	        		DCubicRowDx(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDx);
	        		DCubicRowDy(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDy);
	        		DCubicRowDz(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDz);
				    DDCubicRow_xx(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xx);
	                DDCubicRow_yy(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_yy);
	                DDCubicRow_zz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_zz);
	                DDCubicRow_xy(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xy);
	                DDCubicRow_xz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xz);
	                DDCubicRow_yz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_yz);  
                    goto finish;

			
				//Interpolate in D;
				}
				else 
				{
					whichTetra(i, k, 4);
		            CubicMatrix(nb_xyz_, n, tetra_xyz_, Cmat_);
                    Wvector(nb_xyz_, nb_uvw_, n, tetra_xyz_, tetra_uvw_, W_,1);
		          	LinearQ(plist[0],plist[1],plist[2],tetra_xyz_, tetra_uvw_, Phi_Linear,1);
         			DLinearQdx(tetra_xyz_, tetra_uvw_, DPhi_LinearDx,1);
         			DLinearQdy(tetra_xyz_, tetra_uvw_, DPhi_LinearDy,1);
          			DLinearQdz(tetra_xyz_, tetra_uvw_, DPhi_LinearDz,1);
                    CubicRow(plist[0], plist[1], plist[2], tetra_xyz_, PhiPhi);
         			DCubicRowDx(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDx);
         			DCubicRowDy(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDy);
          			DCubicRowDz(plist[0], plist[1], plist[2], tetra_xyz_, DPhiPhiDz);

					DDCubicRow_xx(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xx);
	                DDCubicRow_yy(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_yy);
	                DDCubicRow_zz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_zz);
	                DDCubicRow_xy(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xy);
	                DDCubicRow_xz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_xz);
	                DDCubicRow_yz(plist[0], plist[1], plist[2],tetra_xyz_, DDPhiPhi_yz);   
                
				//Interpolate in E;
				
				}
			}
		}
	} 
finish:
	for(kk=0; kk<n; kk++)
		for(j=0; j<6; j++)  TCmat_[j*n+kk]=Cmat(kk,j);
	
//	Transpose(Cmat_,n,6,TCmat);
    MatMatProduct(TCCmat_,TCmat_, Cmat_, 6, n, 6);
	for(kk=0; kk<3; kk++)
	{
		for(j=0; j<n; j++)  WW[j]=W_[kk*n+j];
		MatVecProduct(TCW_, TCmat_, WW, 6, n);
		for(j=0; j<6; j++)		bQR(kk+1,j+1)=TCW_[j];

	
	}

	
	for(kk=0; kk<6; kk++)
	{
		for(j=0; j<6; j++)
		{
			uQR(kk+1,j+1)=TCCmat(kk,j);
		
		}
	}



    svdcmp(uQR_,6,6,wQR_,vQR_);
	wmax=0.0;
	for(j=1; j<=6; j++) if (wQR(j) > wmax) wmax=wQR(j);
	wmin = wmax*1.0e-6;
	for(j=1; j<=6; j++) if (wQR(j) < wmin) wQR(j)=0.0;
	

	

	for(kk=1; kk<=3; kk++)
	{
		for(j=1;j<=6; j++)  
		{
			b[j]=bQR(kk,j);
			A[j]=AQR(kk,j);    }
		svbksb(uQR_,wQR_,vQR_,6,6,b,A);
		for(j=1; j<=6; j++)  A0_[kk-1][j-1]=A[j];
	}	
        for(j=0; j<3; j++)
		{
		    uvw_Inter[j]=Phi_Linear[j] + Dotn(A0_[j],PhiPhi,6);
			Duvw_InterDx[j]=DPhi_LinearDx[j] + Dotn(A0_[j],DPhiPhiDx,6);
			Duvw_InterDy[j]=DPhi_LinearDy[j] + Dotn(A0_[j],DPhiPhiDy,6);
			Duvw_InterDz[j]=DPhi_LinearDz[j] + Dotn(A0_[j],DPhiPhiDz,6)
		}  
} 

/**************************************************************************/
double TauP(double vis, double rp)
/**************************************************************************/
{
	return (2.*rp*rp*rhop/(9.*vis));
}
/**************************************************************************/
double ReP(double uvwP[], double VF[], double vis, double rp)
/**************************************************************************/
{
	double  result;

 	VecMinus(uvwP,VF,tmp8_);
	result= sqrt(Dot(tmp8_,tmp8_))*2.*rp*rho/vis ;
 
	return  result;
}


/**************************************************************************/
void GUVXY_beads(int stage, int pn,int iter1,int i[], double t, double h, typexyz Vp0_[],typexyz Vp1_[],typexyz Ap1_[],typexyz Af1_[],
				 typexyz Vf0_[],typexyz Vf2_[],typexyz Wp_[],typeseed2 Epsp_[],typescalar Tp0_[],typescalar Tp1_[],typescalar Tf2_[],typescalar dTp1_[],typescalar dTf1_[],
				 typescalar alpha_chp1_[], typexyz xyz0_[],typexyz xyz1_[], double vis, double Df[])
/**************************************************************************/
{
	int        ii,j, k,n,nv,m, mm, kk;

	double    VIS,  mag1, v_mag,Cp1,Pr1;
	double    y2[3]; 
	double   xyz1[3], Wp[3], Vp0[3],Vp1[3], Vf00[3],Vf0[3], Vf2[3], alpha_chp1[1],Epsp[4], Tp1[1],Tp0[1],Tf2[1],tf00;
	double   Ap1[3],dTp1[1];
	double   Af1[3],dTf1[1];
	double   Tf0_[1],xyz0[3],Vf00_[3];

	if(P_shape==Ellipsoid || P_shape==RBC)         
	{
		if(heat==1)  nv=15;
		else         nv=13;
	}
	else if(P_shape==0)    
	{
		if(heat==1)   nv=8;
		else          nv=6;
	}
	else if(P_shape==DNA)    nv=8;

	if(Refulsive_signal==0)
	{
		for(j=0; j<3; j++)   
	    {
			Sum_WFrepul_[j]=0.;
			Sum_WTrepul_[j]=0.;
		}
	}
	n=nv*Nb;
	if(stage==1)
	{
		if(P_shape==DNA)
	    {
	        for(ii=0; ii<n; ii++)    /* initialization */
	        {
		        for(j=0; j<n; j++)
		        {
					if(ii==j)
			        {
				        Df[n*ii+j]=1./(Gamma*h);
			        }
			        else   Df[n*ii+j]= 0.;
			    }
		    }
	    }
	    else
	    {
		    for(ii=0; ii<n; ii++)
			    for(j=0; j<n; j++)   Df[n*ii+j]= 0.;
	    }
	}

	for(k=0; k<Nb; k++)
	{
		for(j=0; j<3; j++)   
	    {
			xyz0[j]=xyz0_[k].v1[j];
		    xyz1[j]=xyz1_[k].v1[j];
		    Vf0[j]=Vf0_[k].v1[j];
			Vf2[j]=Vf2_[k].v1[j];
			Ap1[j]=Ap1_[k].v1[j];
			Af1[j]=Af1_[k].v1[j];
			Vp1[j]=Vp1_[k].v1[j];
			Vp0[j]=Vp0_[k].v1[j];
			
            if(P_shape==Ellipsoid || P_shape==RBC)
		    {
				Wp[j]=Wp_[k].v1[j];
		    }
		}
		if(iter1==1)  
		{
			Vf00[0]=Vp1[0];
		    Vf00[1]=Vp1[1];
		    Vf00[2]=Vp1[2];
		}
		else
		{
			Vf00[0]=uF(iter1-1,k);
		    Vf00[1]=vF(iter1-1,k);
		    Vf00[2]=wF(iter1-1,k);
		}
		if(P_shape==Ellipsoid || P_shape==RBC)
	    {
			for(j=0; j<4; j++)   Epsp[j]=Epsp_[k].v[j];
	    }
		if(heat)
		{
		    alpha_chp1[0]=alpha_chp1_[k].v[0];
            Tp1[0]=Tp1_[k].v[0];
			Tp0[0]=Tp0_[k].v[0];
			Tf2[0]=Tf2_[k].v[0];
			dTp1[0]=dTp1_[k].v[0];
			dTf1[0]=dTf1_[k].v[0];

			if(iter1==1)  tf00= Tp1[0];
			else          tf00=tempF(iter1-1,k);
		}
        if (Mesh==Hexa)       lopas[k]=Inew4(xyz1, i[k]);
		else if(Mesh==Tetra)  
		{
			lopas[k]=InewTetra(xyz1, i[k]);
			if(CPIT(lopas[k])==4)
			{
				lopas[k]=Cell_search(lopas[k], xyz1);
			}
		}
		v_mag=sqrt(Dot(Vp1,Vp1));

		if(NEWTONIAN==1)
		{
			if(STEADY==1)   
			{
				if(P_shape==Ellipsoid)  
				{
					SteadyInter1(lopas[k], t, xyz1, Vf1_, DVf1Dx_, DVf1Dy_, DVf1Dz_, DDVf1_xx_, DDVf1_yy_,DDVf1_zz_,DDVf1_xy_,DDVf1_xz_,DDVf1_yz_, 
						Tf1_, DTf1Dx_, DTf1Dy_, DTf1Dz_, DDTf1_xx_, DDTf1_yy_,DDTf1_zz_,DDTf1_xy_,DDTf1_xz_,DDTf1_yz_);	
					lopas[k]=InewTetra(xyz1, lopas[k]);
			        if(CPIT(lopas[k])==4)
			        {
						 lopas[k]=Cell_search(lopas[k], xyz1);
			        }
					SteadyInter0(lopas[k], t, xyz0, Vf00_,Tf0_);
				}
			}
		}
		else
		{
			if(STEADY==1)   
	        {
				SteadyInter1(lopas[k], t, xyz1, Vf1_, DVf1Dx_, DVf1Dy_, DVf1Dz_, DDVf1_xx_, DDVf1_yy_,DDVf1_zz_,DDVf1_xy_,DDVf1_xz_,DDVf1_yz_, 					                            Tf1_, DTf1Dx_, DTf1Dy_, DTf1Dz_, DDTf1_xx_, DDTf1_yy_,DDTf1_zz_,DDTf1_xy_,DDTf1_xz_,DDTf1_yz_);
				SteadyInter0(lopas[k], t, xyz0, Vf00_,Tf0_);
			}
 
		}
		
		Drag=ffpvar(pn)*vis;
		mag1=sqrt(Dot(Vf1_,Vf1_));
	
		if(P_shape==Ellipsoid)  
		{
			Transform_A(Wp,Epsp, DVf1Dx_, DVf1Dy_, DVf1Dz_,DDVf1_xx_, DDVf1_yy_,DDVf1_zz_,DDVf1_xy_,DDVf1_xz_,DDVf1_yz_);
			Make_ellipsoid_in_Solver(pn,xyz1 ,Epsp,y2);
			Make_ellipsoid_GVX(Vp1, Vf1_,Wp);
			RefulsiveForce_Ellipsoid(pn,xyz1);
		}
   if(stage==1)
   {
  

		if(effect==1 || effect==2)
		{
			if(P_shape==Ellipsoid)
			{
				m=nv*k;

				for(j=0; j<3; j++)   
				{
					for(kk=0; kk<3; kk++)
					{
						if(j==kk)   Df[(m+j)*n+(m+kk)] =  1./(Gamma*h) + (vis*PI*Rpvar1(pn)*KMat(j+1,kk+1)/Mp);
						else        Df[(m+j)*n+(m+kk)] = (vis*PI*Rpvar1(pn)*KMat(j+1,kk+1)/Mp);
					}
					

					Df[(m+j)*n+(m+3)]= (-vis*PI*Rpvar1(pn)*(KMat(j+1,1)*DVf1Dx_[0] + KMat(j+1,2)*DVf1Dx_[1] + KMat(j+1,3)*DVf1Dx_[2])/Mp);
					Df[(m+j)*n+(m+4)]= (-vis*PI*Rpvar1(pn)*(KMat(j+1,1)*DVf1Dy_[0] + KMat(j+1,2)*DVf1Dy_[1] + KMat(j+1,3)*DVf1Dy_[2])/Mp);
					Df[(m+j)*n+(m+5)]= (-vis*PI*Rpvar1(pn)*(KMat(j+1,1)*DVf1Dz_[0] + KMat(j+1,2)*DVf1Dz_[1] + KMat(j+1,3)*DVf1Dz_[2])/Mp);

					Df[(m+j)*n+(m+9)]= (vis*PI*Rpvar1(pn)*( dKMat_e1(j+1,1)*(Vp1[0] - Vf1(0)) + dKMat_e1(j+1,2)*(Vp1[1] - Vf1(1)) + dKMat_e1(j+1,3)*(Vp1[2] - Vf1(2)) )/Mp);
			        Df[(m+j)*n+(m+10)]= (vis*PI*Rpvar1(pn)*( dKMat_e2(j+1,1)*(Vp1[0] - Vf1(0)) + dKMat_e2(j+1,2)*(Vp1[1] - Vf1(1)) + dKMat_e2(j+1,3)*(Vp1[2] - Vf1(2)) )/Mp);
			        Df[(m+j)*n+(m+11)]= (vis*PI*Rpvar1(pn)*( dKMat_e3(j+1,1)*(Vp1[0] - Vf1(0)) + dKMat_e3(j+1,2)*(Vp1[1] - Vf1(1)) + dKMat_e3(j+1,3)*(Vp1[2] - Vf1(2)) )/Mp);
			        Df[(m+j)*n+(m+12)]= (vis*PI*Rpvar1(pn)*( dKMat_e4(j+1,1)*(Vp1[0] - Vf1(0)) + dKMat_e4(j+1,2)*(Vp1[1] - Vf1(1)) + dKMat_e4(j+1,3)*(Vp1[2] - Vf1(2)) )/Mp);		
			    }

				Df[(m+3)*n+(m+0)]= (-1.); 
				Df[(m+3)*n+(m+3)]= 1./(Gamma*h);

                Df[(m+4)*n+(m+1)]= (-1.);
				Df[(m+4)*n+(m+4)]= 1./(Gamma*h);
                Df[(m+5)*n+(m+2)]= (-1.);
				Df[(m+5)*n+(m+5)]= 1./(Gamma*h);
		 
			    Df[(m+6)*n+(m+6)]=  1./(Gamma*h) + (dThdo_[0]/Ip[0]);
			    Df[(m+6)*n+(m+7)]=  (-Wp[2]*(Ip[1]-Ip[2])/Ip[0]);
			    Df[(m+6)*n+(m+8)]=  (-Wp[1]*(Ip[1]-Ip[2])/Ip[0]);

			    Df[(m+7)*n+(m+7)]=  1./(Gamma*h) + (dThdo_[1]/Ip[1]);
			
			    Df[(m+8)*n+(m+6)]= (-Wp[1]*(Ip[0]-Ip[1])/Ip[2]);
			    Df[(m+8)*n+(m+7)]= (-Wp[0]*(Ip[0]-Ip[1])/Ip[2]);
			    Df[(m+8)*n+(m+8)]= 1./(Gamma*h) + (dThdo_[2]/Ip[2]);

			    Df[(m+9)*n+(m+6)]= (-0.5*Epsp[3]);
			    Df[(m+9)*n+(m+7)]= ( 0.5*Epsp[2]);
			    Df[(m+9)*n+(m+8)]= (-0.5*Epsp[1]);
				Df[(m+9)*n+(m+9)]= 1./(Gamma*h); 
			    Df[(m+9)*n+(m+10)]= (-0.5*Wp[2]);
			    Df[(m+9)*n+(m+11)]= ( 0.5*Wp[1]);
			    Df[(m+9)*n+(m+12)]= (-0.5*Wp[0]);

			    Df[(m+10)*n+(m+6)]= (-0.5*Epsp[2]);
			    Df[(m+10)*n+(m+7)]= (-0.5*Epsp[3]);
			    Df[(m+10)*n+(m+8)]=  (0.5*Epsp[0]);
			    Df[(m+10)*n+(m+9)]=  (0.5*Wp[2]);
				Df[(m+10)*n+(m+10)]= 1./(Gamma*h); 
			    Df[(m+10)*n+(m+11)]= (-0.5*Wp[0]);
			    Df[(m+10)*n+(m+12)]= (-0.5*Wp[1]);

			    Df[(m+11)*n+(m+6)]=  (0.5*Epsp[1]);
			    Df[(m+11)*n+(m+7)]= (-0.5*Epsp[0]);
			    Df[(m+11)*n+(m+8)]= (-0.5*Epsp[3]);
			    Df[(m+11)*n+(m+9)]= (-0.5*Wp[1]);
			    Df[(m+11)*n+(m+10)]= (0.5*Wp[0]);
				Df[(m+11)*n+(m+11)]= 1./(Gamma*h); 
			    Df[(m+11)*n+(m+12)]= (-0.5*Wp[2]);

		    	Df[(m+12)*n+(m+6)]=  (0.5*Epsp[0]);
			    Df[(m+12)*n+(m+7)]=  (0.5*Epsp[1]);
			    Df[(m+12)*n+(m+8)]=  (0.5*Epsp[2]);
			    Df[(m+12)*n+(m+9)]=  (0.5*Wp[0]);
			    Df[(m+12)*n+(m+10)]= (0.5*Wp[1]);
			    Df[(m+12)*n+(m+11)]= (0.5*Wp[2]);
				Df[(m+12)*n+(m+12)]= 1./(Gamma*h); 
				if(heat)
				{
					Df[(m+13)*n+(m+13)]= 1./(Gamma*h) + Nu/TRexTime;
		
    			    Df[(m+14)*n+(m+13)]= (-M0*dKon_inter_x(Tp1[0], v_mag)*pow(1.-alpha_chp1[0],2.) + dKoff_inter_x(Tp1[0], v_mag)*alpha_chp1[0]);
	    		    Df[(m+14)*n+(m+14)]= 1./(Gamma*h) + (M0*2.*Kon_inter(Tp1[0], v_mag)*(1.-alpha_chp1[0]) + Koff_inter(Tp1[0], v_mag));
				}
			}
		}
			
   }
        m=nv*k;
		for(j=0; j<nv; j++)  
		{
			if (j<3) 
			{	
					if(P_shape==Ellipsoid || P_shape==RBC)  
					{
						if(j==0)        GVX(k*nv+j) = GVX_E(0) + alpha*(Vf2[0] - Vf0[0])/h + ( Sum_Frep(0)+Sum_WFrepul_[0] )/Mp ;// + F_flagelar*y2[0]/Mp;  // + Sec_Vis_F[i]/Mp;
					    else if(j==1)   GVX(k*nv+j) = GVX_E(1) + alpha*(Vf2[1] - Vf0[1])/h + ( Sum_Frep(1)+Sum_WFrepul_[1] )/Mp ; // + F_flagelar*y2[1]/Mp; 
					    else if(j==2)   GVX(k*nv+j) = GVX_E(2) + alpha*(Vf2[2] - Vf0[2])/h + ( Sum_Frep(2)+Sum_WFrepul_[2] )/Mp ; // + F_flagelar*y2[2]/Mp; 
						DFdt0(k*nv+j)= 0. ;
					}
			}
			else if( j>=3 && j<6)
		    {		
				if(effect==1 || effect==2 || effect==3 || effect==4)
				{
					GVX(k*nv+j) = Vp1[j-3];// + 0.5*(Sum_Frep(j-3)+Sum_WFrepul_[j-3] )*h/Mp;
				    DFdt0(k*nv+j)=0.; //Ap1[j-3];
				}
			}
			else if( j>=6 && j<nv)
			{		
				if(P_shape==Ellipsoid)
				{
					if(j==6)       GVX(k*nv+j) = GVX_E(3) + ( Sum_Trep(0)+ Sum_WTrepul_[0])/Ip[0];
				    else if(j==7)  GVX(k*nv+j) = GVX_E(4) + ( Sum_Trep(1)+ Sum_WTrepul_[1])/Ip[1] ;  //+ T_flagelar/Ip[1];
				    else if(j==8)  GVX(k*nv+j) = GVX_E(5) + ( Sum_Trep(2)+ Sum_WTrepul_[2])/Ip[2];
				    else if(j==9)  GVX(k*nv+j) = 0.5*(Epsp[3]*Wp[0]-Epsp[2]*Wp[1]+Epsp[1]*Wp[2]);
				    else if(j==10) GVX(k*nv+j) = 0.5*(Epsp[2]*Wp[0]+Epsp[3]*Wp[1]-Epsp[0]*Wp[2]);
				    else if(j==11) GVX(k*nv+j) = 0.5*(-Epsp[1]*Wp[0]+Epsp[0]*Wp[1]+Epsp[3]*Wp[2]);
				    else if(j==12) GVX(k*nv+j) = 0.5*(-Epsp[0]*Wp[0]-Epsp[1]*Wp[1]-Epsp[2]*Wp[2]);
			        DFdt0(k*nv+j)=  0.;
				}
			}
		}

	}

}





/**************************************************************************/
double T0(double t)
/**************************************************************************/
{
	return  ( TimeStep*(  (int)(RoundOff(t/TimeStep)) ) );
}
/**************************************************************************/
double T1(double t)
/**************************************************************************/
{
	return (T0(t)+TimeStep);
}
/**************************************************************************/
double T11(double t)
/**************************************************************************/
{
	return (T1(t) + TimeStep);
}
/**************************************************************************/
double T01(double t)
/**************************************************************************/
{
	return (T0(t) - TimeStep);
}
/**************************************************************************/
double Tau(double t)
/**************************************************************************/
{
	return (t-T0(t))/TimeStep;
}
/**************************************************************************/
void LinearInter0( int Lo, double time, double plist[],double temp1[], double output2[] ) // version 1.0b
/**************************************************************************/
{
	int    j;
	double  a00, a10;


	a00=1.-Tau(time);
	a10=Tau(time);


	TetraDecompInter(Lo, T0(time), plist, BVel00_);
	TetraDecompInter(Lo, T1(time), plist, BVel10_);


    
	for(j=0; j<3; j++)
	{
		temp1[j]=  a00*BVel00(j) + a10*BVel10(j); 
	}

    if(Magnet)
	{
	
		TetraDecomp(Lo, 0., plist);
	    ScatterInter(Lo, plist, nb_Fmag_, tetra_Fmag_, output2,1);
	}
}

/**************************************************************************/
void LinearInter1( int Lo, double time, double plist[],double output[], double DoutputDx[], double DoutputDy[], double DoutputDz[] , double output2[]) // version 2.0b
/**************************************************************************/
{
	int    j;
	double   a00, a10;

	

	a00=1.-Tau(time);
	a10=Tau(time);



	TetraDecompInter2(Lo, T0(time), plist, BVel00_ ,DBVel00Dx_, DBVel00Dy_, DBVel00Dz_);
	TetraDecompInter2(Lo, T1(time), plist, BVel10_, DBVel10Dx_, DBVel10Dy_, DBVel10Dz_);

	for(j=0; j<3; j++)
	{
		output[j]=  a00*BVel00(j) + a10*BVel10(j) ; 
		DoutputDx[j]=  a00*DBVel00Dx(j) + a10*DBVel10Dx(j); 
		DoutputDy[j]=  a00*DBVel00Dy(j) + a10*DBVel10Dy(j); 
		DoutputDz[j]=  a00*DBVel00Dz(j) + a10*DBVel10Dz(j); 
	}
	if(Magnet)
	{
		TetraDecomp(Lo, 0., plist);
	    ScatterInter(Lo, plist, nb_Fmag_, tetra_Fmag_, output2,1);
	}



}

/**************************************************************************/
void SteadyInter0( int Lo, double time, double plist[],double output1[], double output2[]) 
/**************************************************************************/
{
	TetraDecomp(Lo, 0., plist);
	ScatterInter(Lo, plist, nb_uvw_, tetra_uvw_, output1,1);
	ScatterInter(Lo, plist, nb_t_, tetra_t_, output2,0);
	if(Magnet)  ScatterInter(Lo, plist, nb_Fmag_, tetra_Fmag_, output2,1);

	if(Interpolation==InverseD)  delete w;
}
/**************************************************************************/
void SteadyInter1( int Lo, double time, double plist[],
				  double output[], double DoutputDx[], double DoutputDy[], double DoutputDz[],
				  double DDoutput_xx[],double DDoutput_yy[],double DDoutput_zz[],double DDoutput_xy[],double DDoutput_xz[],double DDoutput_yz[],
				  double output2[],double Doutput2Dx[], double Doutput2Dy[], double Doutput2Dz[],
				  double DDoutput2_xx[],double DDoutput2_yy[],double DDoutput2_zz[],double DDoutput2_xy[],double DDoutput2_xz[],double DDoutput2_yz[]) // version 2.0b
/**************************************************************************/
{
	TetraDecomp(Lo, 0., plist);
    ScatterInter2(Lo, plist, nb_uvw_, tetra_uvw_, output, DoutputDx, DoutputDy, DoutputDz,DDoutput_xx,DDoutput_yy,DDoutput_zz,
		DDoutput_xy,DDoutput_xz,DDoutput_yz,1);

	ScatterInter2(Lo, plist, nb_t_, tetra_t_, output2, Doutput2Dx, Doutput2Dy, Doutput2Dz,DDoutput2_xx,DDoutput2_yy,DDoutput2_zz,
		DDoutput2_xy,DDoutput2_xz,DDoutput2_yz,0);

//	ScatterInter(Lo, plist, nb_t_, tetra_t_, output2,0);
	if(Magnet)  ScatterInter(Lo, plist, nb_Fmag_, tetra_Fmag_, output2,1);
	if(Interpolation==InverseD)   delete w;
	
}

/**************************************************************************/
void RosenStiff1(int pn, int iter1, int i[],double t, double Tau, double vis, typexyz Vp0_[],typexyz Vp1_[],typexyz Ap_[],typexyz Af_[],
				 typescalar Tp0_[],typescalar Tp1_[],typescalar dTpdt1_[],typescalar dTfdt1_[],typescalar alpah_p_[], 
				 typexyz xyz0_[], typexyz xyz1_[], typexyz Wp_[], typeseed2 Epsp_[])
/**************************************************************************/
{
	double tn;
	double  d;

	double  VIS, Mr;
	int    j,k,n, count,flag,m, nv;
	double h, errmax, hdid, hnext, vmag1,vmag2;
	double theta, phi;
	double y2[3], C[15];

	

	double xyz0[3],xyz1[3],Vp1[3],Vp0[3],Tp1[1],Tp0[1],alpah_p[1],Epsp[4],Wp[3];
	double  dupdt[3],dTpdt1[1],dTfdt1[1];



	if(P_shape==Ellipsoid) 
	{
		C[0]=1.;
		C[1]=C[0];
		C[2]=C[0];
		C[3]=1.;
		C[4]=C[3];
		C[5]=C[3];
		omega_max=Vel_max/MIN(Ra,Rb);
		//omega_max=Vel_max/0.5e-6;
		C[6]=omega_max;
		C[7]=C[6];
		C[8]=C[6];
		C[9]=1.;
		C[10]=1.;
		C[11]=1.;
		C[12]=1.;
		C[13]=1.;
		C[14]=1.;
	}
	
	else if(P_shape==Ellipsoid)    
	{
		Nb=1;
		nv=13;
	}
    n=nv*Nb;
  

	k=0;
	/* first stage */
	h=Tau;

	for(m=0; m<Nb; m++)
	{
		for(j=0; j<3; j++)   
	    {
			xyz0[j]=xyz0_[m].v1[j];
		    xyz1[j]=xyz1_[m].v1[j];
		    Vp1[j]=Vp1_[m].v1[j];
			Vp0[j]=Vp0_[m].v1[j];
			dupdt[j]=Ap_[m].v1[j];
            if(P_shape==Ellipsoid || P_shape==RBC)
		    {
				Wp[j]=Wp_[m].v1[j];
			}
		}
		if(P_shape==Ellipsoid)
		{
			for(j=0; j<4; j++)   Epsp[j]=Epsp_[m].v[j];
		}


		if(Mesh==Tetra)  
		{
			lopas[m]=InewTetra(xyz1, i[m]);
			if(CPIT(lopas[m])==4)
			{
				lopas[m]=Cell_search(lopas[m], xyz1);
			}
		}


	    if(STEADY==1)   
	    {
			SteadyInter1(lopas[m], t, xyz1, &uvwF0_[m].v1[0], DuvwF0Dx_, DuvwF0Dy_, DuvwF0Dz_, DDuvwF0_xx_, DDuvwF0_yy_,DDuvwF0_zz_,DDuvwF0_xy_,DDuvwF0_xz_,DDuvwF0_yz_, 
				                            &tF0_[m].v[0], DTf0Dx_, DTf0Dy_, DTf0Dz_, DDTf1_xx_, DDTf1_yy_,DDTf1_zz_,DDTf1_xy_,DDTf1_xz_,DDTf1_yz_);

		   //if(Magnet)      SteadyInter1(lopas[m], t, xyz1, &uvwF0_[m].v1[0], DuvwF0Dx_, DuvwF0Dy_, DuvwF0Dz_,DDuvwF0_xx_, DDuvwF0_yy_,DDuvwF0_zz_,DDuvwF0_xy_,DDuvwF0_xz_,DDuvwF0_yz_, Fmag0_); 
	    }

	    if(P_shape==Ellipsoid)  
	    {
		    Transform_A( Wp, Epsp,DuvwF0Dx_, DuvwF0Dy_, DuvwF0Dz_, DDuvwF0_xx_, DDuvwF0_yy_,DDuvwF0_zz_,DDuvwF0_xy_,DDuvwF0_xz_,DDuvwF0_yz_);
		    Make_ellipsoid_in_Solver(pn,xyz1,Epsp,y2);
	    }
		

	    if(NEWTONIAN == 1)    VIS=vis;
	    else              
	    {
		    VIS=Mod_Powell_Model(Shear);
	    }
	    for(j=0; j<6; j++)
	    {
		    if(j<3)
		    {
		    	uvxy(nv*m+j)=Vp1[j];
		    }
		    else if (j>= 3 && j<6 )
		    {
		    	uvxy(nv*m+j)=xyz1[j-3];
		    }
	    }
	    if(P_shape==Ellipsoid )
	    {
		    uvxy(nv*m+6)=Wp[0];
		    uvxy(nv*m+7)=Wp[1];
		    uvxy(nv*m+8)=Wp[2];
		
		    uvxy(nv*m+9)=Epsp[0];
		    uvxy(nv*m+10)=Epsp[1];
		    uvxy(nv*m+11)=Epsp[2];;
		    uvxy(nv*m+12)=Epsp[3];
			if(heat)
			{
		       uvxy(nv*m+13)=Tp1[0];
		       uvxy(nv*m+14)=alpah_p[0];
			}
	    }
	    count=0;
	}
Again: 


	k++;
    if(k<=40)
	{
		for(m=0; m<Nb; m++)
		{
		    for(j=0; j<3; j++)   xyzPress(m,j)=xyz1_[m].v1[j] + h*Vp1_[m].v1[j];;
    
		    if(Mesh==Tetra)             
			{
				lopas[m]=InewTetra(&xyzPress_[m].v1[0], i[m]);
			}
		    if(lopas[m]<0 )
		    {
			    if(WallCell(i[m]) ==3)
			    {
				    h=0.5*h;
				    for(j=0; j<3; j++)    uvwF1(m,j)=0.;
				
					if(Mesh==Tetra)  
					{
						lopas[m]=InewTetra(&xyz1_[m].v1[0], i[m]);
					}
    
					if(OutletCell(i[m])==1)  goto Stop;

			    
			    }
			    else    
			    {
				    h=0.5*h;
				    goto  Again;
			    }
		    }
		    else
		    {
			    if(STEADY==1)   
			    {
				    SteadyInter0(lopas[m], t+h, &xyzPress_[m].v1[0],  &uvwF1_[m].v1[0],&tF1_[m].v[0]);
				    if(Magnet)  SteadyInter0(lopas[m], t+h, &xyzPress_[m].v1[0], &uvwF1_[m].v1[0], Fmag0_);
				}
		    }

		    if(Mesh==Tetra)  
			{
				lopas[m]=InewTetra(&xyz1_[m].v1[0], lopas[m]);
			}
		}
 
    
		GUVXY_beads(1,pn,iter1, lopas, t ,h, Vp0_,Vp1_,Ap_,Af_, uvwF0_, uvwF1_, Wp_, Epsp_, Tp0_,Tp1_,tF1_,dTpdt1_,dTfdt1_, alpah_p_, xyz0_,xyz1_, VIS, AA0_);
		for(j=0; j<n*n; j++)    AA_[j]=AA0_[j];
		ludcmp(AA_,n,index_,&d);
		

/*----------------------------------------------------------------------------------------------------*/		    
	    for(j=0; j<n ; j++)  g1(j)=GVX(j) + h*c1x* DFdt0(j);
        lubksb(AA_,n,index_,g1_);
		for(j=0; j<n; j++)
		{
			uvxyn(j)=uvxy(j) + a21*g1(j);
		}
		
		for(m=0; m<Nb; m++)
		{
			for(j=0; j<3; j++)
			{
				uvwP(m,j)=uvxyn(m*nv+j);
			    xyzP(m,j)=uvxyn(m*nv+j+3);
				if(P_shape==Ellipsoid   
				{
					omegaP(m,j)=uvxyn(m*nv+j+6); 
				}
			}
			if(P_shape==Ellipsoid)  
			{
				 epsP_[m].v[0]=uvxyn(m*nv+9);
				 epsP_[m].v[1]=uvxyn(m*nv+10);
				 epsP_[m].v[2]=uvxyn(m*nv+11);
				 epsP_[m].v[3]=uvxyn(m*nv+12);

			 }
		}
		/* second stage */
    	tn = t + a2x * h;

		for(m=0; m<Nb; m++)
		{
			if(Mesh==Tetra)  
			{
				lopas[m]=InewTetra(&xyzPP_[m].v1[0], lopas[m]);
			}
		}
		GUVXY_beads(1,pn,iter1, lopas, tn , h ,Vp0_,uvwPP_,Ap_,Af_, uvwF0_,uvwF1_ ,omegaP_,epsP_,Tp0_,tPP_,tF1_,dTpdt1_,dTfdt1_,alpha_chPP_, xyz0_,xyzPP_, VIS,AA0_);
		for(j=0; j<n*n; j++)    AA_[j]=AA0_[j];
		ludcmp(AA_,n,index_,&d);
/*----------------------------------------------------------------------------------------------------*/        
        for(j=0; j<n; j++)
		{
	     	g2(j)=GVX(j) + h*c2x * DFdt0(j) + c21*g1(j)/h;
		}
	    lubksb(AA_,n,index_,g2_);	
		for(j=0; j<n; j++)
		{
			uvxyn(j)=uvxy(j) + a31*g1(j) + a32*g2(j);
		}
		for(m=0; m<Nb; m++)
		{
			for(j=0; j<3; j++)
			{
				uvwP(m,j)=uvxyn(m*nv+j);
			    xyzP(m,j)=uvxyn(m*nv+j+3);
			    omegaP(m,j)=uvxyn(m*nv+j+6); 
			}
		    for(j=0; j<4; j++)    epsP_[m].v[j]=uvxyn(m*nv+9+j);
		}
        
    	tn = t + a3x * h;

        for(m=0; m<Nb; m++)
		{
		    if(Mesh==Tetra)  
			{
				lopas[m]=InewTetra(&xyzPP_[m].v1[0], lopas[m]);
			}
		    if(lopas[m]<0 && (Bregion(-lopas[m])==0 || Bregion(-lopas[m])==3))
		    {
			    h=0.5*h;
			    goto Again;
		    }
		    else if (lopas[m]<0 && Bregion(-lopas[m])==2)
		    {
			    goto Stop;
		    }
		    else if (lopas[m]<0 && Bregion(-lopas[m])==1)
		    {
			    h=0.5*h;
			    goto Again;
		    }
		}       
		GUVXY_beads(1,pn,iter1,lopas, tn,h,Vp0_,uvwPP_,Ap_ ,Af_, uvwF0_,uvwF1_,omegaP_, epsP_,Tp0_,tPP_,tF1_,dTpdt1_,dTfdt1_,alpha_chPP_, xyz0_,xyzPP_, VIS,AA0_);
		for(j=0; j<n*n; j++)    AA_[j]=AA0_[j];
		ludcmp(AA_,n,index_,&d);     
/*----------------------------------------------------------------------------------------------------*/		
    	for(j=0; j<n; j++)
		{
	    	g3(j)=GVX(j) + h*c3x* DFdt0(j) + (c31*g1(j) + c32*g2(j))/h;
		}
    	lubksb(AA_,n,index_,g3_);
		
    	for(j=0; j<n; j++)
		{
    		g4(j)=GVX(j) + h*c4x* DFdt0(j) + (c41*g1(j) + c42*g2(j) + c43*g3(j))/h;
		}
    	lubksb(AA_,n,index_,g4_);
        for(j=0; j<n; j++)
		{
    		uvxyn(j) = uvxy(j) + b1*g1(j) + b2*g2(j) + b3*g3(j) + b4*g4(j);
    		uvxyer(j) = e1*g1(j) + e2*g2(j) + e3*g3(j) + e4*g4(j);  
		}
		for(m=0; m<Nb; m++)
		{
			for(j=0; j<3; j++)
		    {
				uvwP(m,j)=uvxyn(m*nv+j);
			    xyzP(m,j)=uvxyn(m*nv+j+3);
				omegaP(m,j)=uvxyn(m*nv+j+6); 	
			}
		    if(P_shape==Ellipsoid || P_shape==RBC)
		    {
				epsP_[m].v[0]=uvxyn(m*nv+9);
				epsP_[m].v[1]=uvxyn(m*nv+10);
				epsP_[m].v[2]=uvxyn(m*nv+11);
				epsP_[m].v[3]=uvxyn(m*nv+12);
		    }
		    if(Mesh==Tetra)  
			{
				lopas[m]=InewTetra(&xyzPP_[m].v1[0], lopas[m]);
			}
		    if(Diffuse!=0) 
		    {
			    if(P_shape==Ellipsoid)
			    {
				    Brown_c++;
			        Brown_c=Brown_c%10000;
				    Make_ellipsoid_in_Solver(pn,&xyzPP_[m].v1[0], &epsP_[m].v[0],y2);
				    Ellipsoid_Brownian_Motion(lopas[m],&xyzPP_[m].v1[0],y2,h,Rpvar1(pn));
				    for(j=0; j<3; j++)    xyzP(m,j)=xyzP(m,j) + F_Brown_[m].v1[j];
				    Make_ellipsoid_in_Solver(pn,&xyzPP_[m].v1[0], &epsP_[m].v[0],y2);               
			    }		
			    for(j=3; j<6; j++)
		        {
			        uvxyn(m*nv+j)=xyzP(m,j-3);
			    }
		    }
		}
		
	    errmax=0.0;
		for(m=0; m<Nb; m++)
		{
			    for(j=0; j<nv; j++)    Yscal(j) = MAX(C[j],fabs(uvxyn(m*nv+j)));
    	        for (j=0; j<nv; j++)   errmax = MAX(errmax, fabs(uvxyer(m*nv+j)/Yscal(j)));
		}
    	errmax /= eps;
		if((vmag1>10.) ||(vmag2>10.)) 
		{
			printf(" k= %d errmax= %lf  \n",k,errmax);
		}
    	if (errmax <=1.0)
		{
    		hdid = h;
    		hnext = (errmax > ERRCON ? safety*h*pow(errmax, pgrow) : grow*h);
			goto Finish;
		}
    	else 
		{
     		hnext =safety*h*pow(errmax,pshrnk);
    		h = (h >= 0.0 ? MAX(hnext, shrnk*h) : MIN(hnext, shrnk*h));
			goto Again;
		} 
	}
Stop:   			
	hdid=h;
    hnext=h;
			
	goto Finish;
		
    for(m=0; m<Nb; m++)
	{
		if(Bregion(-lopas[m])==0 || Bregion(-lopas[m])==3)	
	    {
		    for(j=0; j<3; j++) uvxyn(m*nv+3+j)=xyzPress(m,j);
	        hdid=h;
		    hnext=h;
	    }
	    else if(Bregion(-lopas[m])==2)
	    {
		    for(j=0; j<3; j++) uvxyn(m*nv+3+j)=xyzP(m,j);
		    hdid=h;
		    hnext=h;
	    }
	}
Finish:
		uvxyn(n)=hdid;
		uvxyn(n+1)=hnext;
}





void Force_repulsive_Ellipsoid(int pn, double xyzc[], double xyz1[], double xyz0[])   /* particle repulsive force */
/**************************************************************************/
{
	double stiff_max,stiff_min,dist, NN_[3],d,nano,pdist;
	double xyz_contact[3], rxyz[3];
	int i;
	double r1,E_young,poisson,kn,dist_c1,dist_c0; 

//	stiff=3.0e-4;
//	stiff=0.7e-4;

	r1=0.5*5.7e-7;
	E_young=26000.;
	poisson=0.5;



//	v_max=8.0e-3;

	stiff_max=3.2e-4;
	stiff_min=3.16e-6;
	nano=1.0e-9;
//	v_mag=sqrt(Dot(vf,vf));

//	stiff=(stiff_max-stiff_min)/v_max*(v_mag-v_max)+stiff_max;
	
	dist=Distance(xyz1,xyz0);
	dist_c1=Distance(xyzc,xyz1);
	dist_c0=Distance(xyzc,xyz0);
//	pdist=R+Rpvar1(pn); 
	pdist=5.7e-7;
//	force=6.*PI*mu*R*sqrt(Dot(Force0,Force0));

	if(dist>pdist)
	{
		for(i=0; i<3; i++)   
		{
			Frepul_[i]=0.;
			Trepul_[i]=0.;
		}
	}
	else
    { 
		if(dist_c0>=dist_c1)
		{
			for(i=0; i<3; i++)    
			{
				NN_[i]=(xyz1[i]-xyz0[i])/dist;
				xyz_contact[i]=0.5*(xyz1[i]+xyz0[i]);
				rxyz[i]=xyz_contact[i] - xyzc[i];
			}
		    d=pdist-dist;
		}
		else
		{
			for(i=0; i<3; i++)    
			{
				NN_[i]=-(xyz1[i]-xyz0[i])/dist;
				xyz_contact[i]=0.5*(xyz1[i]+xyz0[i]);
				rxyz[i]=xyz_contact[i] - xyzc[i];
			}
		    d=pdist+dist;
		}
	    //  kn=sqrt(2.*r1*d)*E_young/(3.*(1.-poisson*poisson));
	    	kn=stiff_max;
        for(i=0; i<3; i++) 
		{
	//		Frepul_[i]=((stiff_max*d)+force)*NN_[i];
			Frepul_[i]=((kn*d))*NN_[i];
		}
		Cross(rxyz,Frepul_,Trepul_);
		MatVecProduct(Trepul_, Tran_A_, Trepul_, 3, 3);
	//	Frepul_[2]=0.;
	//	DFrepul=(stiff_max*d)*nano/dist;
	}
	
}



double  Spring_force_ellipsoid(double a, double b, double theta)
/**************************************************************************/
{
	double Y1, Y2, poissonR, Effective_Y;

	double p,q;
	double Ramda1,effective_R;
	double det,L1,G1,spring_constant;
	Y1=200.e+3;
	Y2=100.e+6;
	poissonR=0.5;
	Effective_Y=(1.-poissonR*poissonR)/Y1 + (1.-poissonR*poissonR)/Y2;
	Effective_Y=1./Effective_Y;
 

   
	p=a*cos(0.5*PI-theta);
	q=b*sin(0.5*PI-theta);

	effective_R=a*a*b*(p*p/pow(a,4.)+q*q/pow(b,4.));
	Ramda1=b*b*(p*p/pow(a,4.)+q*q/pow(b,4.));

	det=MAX(Ramda1,1./Ramda1);
	L1=log(Ramda1);

	if(det<=10)
	{
		G1=1.+ 0.020789*L1*L1 -4.271e-5 *pow(L1,4.);
	}
	else if(det>10 && det<=100)
	{
		G1=1. + 0.020487*L1*L1;
	}

	spring_constant=4.*Effective_Y*sqrt(effective_R)*G1/3.;

	return spring_constant;
		
}


/**************************************************************************/
void Force_Wall_repulsive4(int pn, int icp, double xyz1[], double uvw1[],double uvwf[], double omega1[], double y2[], double timestep)   /* particle repulsive force at the wall*/
/**************************************************************************/
{
	double   NN1_[3],d,d2,height,height2;
	double xyz0[3],xyz2[3],xyz_beadcenter[3],xyz_bead_contact[3], y2NN[3],x2[3];
	int i,bn1,j,Len1;
	double vec_r[3],r1,r2;
 
 
	double temp1[3], temp2[3];
	double hc;
	int    c_contact;

	double  *xyz_bead_bound;
	int    k,bnlen,icp_bead;

	double stiff_max=0.044;
	double delta_max=50.e-9;
	double delta;

	double  stiff_coef;
	double vmag1, *NN2_,*TT1_,*TT2_,*Op2_, *abc,*N_contact1,*N_contact2, *X1,*X3, *udir;
	double thetac,thetac2, abc_mag;
	double xx1,xx2, yy1,yy2,zz1,zz2,cosRa,sinRb,invRaRb;

	INTVECTOR Bneighbor;
	DOUBLEVECTOR dist1;
	vector<double>::iterator smallest1;

    xyz_bead_bound=new double[3];
	
	NN2_=new double[3];
	TT1_=new double[3];
	TT2_=new double[3];

	Op2_=new double[3];
	abc=new double[3];
	N_contact1=new double[3];
	N_contact2=new double[3];
	X1=new double[3];
	X3=new double[3];
	udir=new double[3];




	double sum2;

    c_contact=0;
	re_calculation=0;

    if(P_shape==Ellipsoid)       Len1=32;
	else if(P_shape==RBC)        Len1=266;
	
	vmag1=sqrt(Dot(uvw1,uvw1));




	for(i=0; i<3; i++)    
	{
		Sum_WFrepul_[i]=0.;
		Sum_WTrepul_[i]=0.;
		WFrepul_[i]=0.;
		WTrepul_[i]=0.;
		udir[i]=uvw1[i]/vmag1;
	}

	for(k=1;k<=7;k++)   //find neighboring lists of boundary where the cell contact
	{
		bn1=NwallJ(icp,k);
	
		if(bn1==0) break;
		else
		{
			Bcenter(bn1,xyz0);
			Nvec2(bn1,NN1_);
		
			
				Cross(y2,NN1_,y2NN);
			    abc_mag=sqrt(Dot(y2NN,y2NN));
			    for(i=0; i<3; i++)   y2NN[i]=y2NN[i]/abc_mag;
        	    Cross(y2NN,y2,X1);
			    abc_mag=sqrt(Dot(X1,X1));
			    for(i=0; i<3; i++)   X1[i]=X1[i]/abc_mag;

			    Cross(NN1_,y2NN,TT1_);
			    abc_mag=sqrt(Dot(TT1_,TT1_));
			    for(i=0; i<3; i++)   TT1_[i]=TT1_[i]/abc_mag;
				Op2_[0]=0.;
	            Op2_[1]=1.;
	            Op2_[2]=0.;			
		
			MatVecProduct(&TT2_[0], Tran_A_, &TT1_[0], 3, 3); 
			MatVecProduct(&NN2_[0], Tran_A_, &NN1_[0], 3, 3);
			MatVecProduct(&X1[0], Tran_A_, &X1[0], 3, 3);

			if(Dot(y2,NN1_)<=0.) 
			{
				abc_mag=Dot(TT1_,y2);
				if(abc_mag>=1.) abc_mag=1.;
				thetac=acos(abc_mag);
				if(thetac<0.)   thetac=thetac+PI;
			}
			else
			{
				abc_mag=Dot(TT1_,y2);
				if(abc_mag>=1.) abc_mag=1.;
				thetac=acos(abc_mag);
				thetac=2.*PI-thetac;
			}


			
			
		/*	XT=Rb*Dot(TT2_,X1);
			YT=-Ra*Dot(TT2_,Op2_);

			if(YT>0)
	        {
				if(XT>0.)         thetac=atan(YT/XT);
	            else              thetac=2.*PI-atan(YT/fabs(XT));  
			}
			else
			{
				if(XT>0.)         thetac=PI-atan(fabs(YT)/XT);
				else              thetac=PI+atan(fabs(YT)/fabs(XT));
			}  */
			cosRa=cos(thetac)/Ra;
			sinRb=sin(thetac)/Rb;
			invRaRb=1./(Ra*Ra)-1./(Rb*Rb);


			xx1=pow((Rb*Rb-Ra*Ra)*sin(thetac)*cos(thetac),2.)*(cosRa*cosRa+sinRb*sinRb);
			yy1=1.+pow((Ra*Rb*invRaRb*sin(thetac)*cos(thetac)),2.);

			if(Dot(y2,NN1_)<=0.)
			{      
				zz1=sqrt(xx1/yy1);
				xx2=-zz1*invRaRb*sin(thetac)*cos(thetac)-sqrt(pow(cosRa,2.) + pow(sinRb,2.) - pow((zz1/Ra/Rb),2.) );
			}
			else
			{   
				zz1=-sqrt(xx1/yy1);
				xx2=-zz1*invRaRb*sin(thetac)*cos(thetac)-sqrt(pow(cosRa,2.) + pow(sinRb,2.) - pow((zz1/Ra/Rb),2.) );
			}

		
			yy2=pow(cosRa,2.)+pow(sinRb,2.);
			zz2=xx2/yy2;

            for(i=0; i<3; i++)
			{
				N_contact1[i]=zz1*TT1_[i]+zz2*NN1_[i];
			}


			
		
			/*	for(i=0; i<3; i++)
			    {
				    N_contact2[i]=-sin(-thetac)*X1[i]+cos(-thetac)*Op2_[i];
			    }
			
			
			MatVecProduct(&N_contact1[0], ITran_A_, &N_contact2[0], 3, 3);


			Cell_contact_length=sqrt(pow(Ra*sin(thetac),2.)+pow(Rb*cos(thetac),2.)); */

			
			VecMinus(xyz1, xyz0, xyz2);
			height=Dot(NN1_,xyz2);
			if(P_shape==Ellipsoid)
			{
			   // hc=Cell_contact_length*Dot(NN1_,N_contact1);
				hc=Dot(NN1_,N_contact1);
				if(hc<0.)
				{
					hc=fabs(hc);
				}
				else
				{
					for(i=0 ;i<3; i++)   N_contact1[i]=-N_contact1[i];
					//hc=fabs(Cell_contact_length*Dot(NN1_,N_contact1));
					hc=fabs(Dot(NN1_,N_contact1));
				}
				thetac2=acos(Dot(y2,N_contact1)/sqrt(Dot(N_contact1,N_contact1)));
				if(thetac2 >0.5*PI)  thetac2=PI - thetac2;
				stiff_coef=Spring_force_ellipsoid(Ra, Rb, thetac2);
				for(i=0; i<3; i++)
			    {
					vec_r[i]=N_contact1[i];
			    }

			}
			else if(P_shape==RBC)
			{
				Cross(y2,NN1_,y2NN);
				Cross(y2NN,y2,x2);
				hc=fabs(Ra*Dot(NN1_,x2));
			}

			if(P_shape==Ellipsoid || P_shape==RBC) 
			{
				r1=4.*Rbead;
				r2=0.5*Rbead;
			}
			else           r1=R;
			d=height-hc;
			if(P_shape==Ellipsoid)
			{
				if(d<0.)
			    {	
				   Bneighbor.push_back(bn1);
			    }
			}
			else if(P_shape==RBC)
			{
				if(height<Rb || height< hc)
			    {	
				   Bneighbor.push_back(bn1);
			    }
			}

			d=height-hc;
		/*	if(d<0.)
			{
				c_contact++;
				if(fabs(d)>= delta_max)
			    {
					//re_calculation=1;
					//goto lab1;
				    delta=delta_max;
			    }
			    else 
					delta=fabs(d);

			  
					if(Dot(udir,TT1_)>0)
					{
						for(i=0; i<3; i++)   WFrepul_[i]=stiff_coef*pow(delta,1.5)*(NN1_[i]+0.2*TT1_[i]);
					}
					else
					{
						for(i=0; i<3; i++)   WFrepul_[i]=stiff_coef*pow(delta,1.5)*(NN1_[i]-0.2*TT1_[i]);
					}


				Cross(vec_r,WFrepul_,WTrepul_);
			    MatVecProduct(WTrepul_, Tran_A_, WTrepul_, 3, 3); 		
			    for(i=0; i<3; i++) 
			    {
				    Sum_WFrepul_[i]+=WFrepul_[i];
				    Sum_WTrepul_[i]+=WTrepul_[i];
			    } 
			    if(delta>repusive_dist_wall)  
			    {
				    for(i=0; i<3; i++)   xyz1[i]= xyz1[i] + 1.5*fabs(d)*(NN1_[i]);
			    }
			    else
			    {
				    for(i=0; i<3; i++)   xyz1[i]= xyz1[i] + 1.5*fabs(d)*(NN1_[i]);
			    }  
			    Make_ellipsoid_in_Solver(pn,xyz1,&epsP2_[0].v[0], y2);
			    sum2=0.;
			    for(i=0; i<3; i++)   sum2 = sum2 + uvw1[i] * NN1_[i];
			    if(sum2<0)
                { 
				    for(i=0; i<3; i++)   temp2[i]= Mp*sum2 * NN1_[i];
				    Cross(vec_r, temp2, temp1);
				    MatVecProduct(temp2, Tran_A_, temp1, 3, 3); 
				    if(SLIP==1) 
				    {
					    for(i=0; i<3; i++)       
					    {
						//   uvw1[i] = uvw1[i] - sum2*NN1_[i];
					     //  omega1[i] = omega1[i] - temp2[i]/Ip[i]; 
					    }
				    }
				    else  
				    {
					    for(i=0; i<3; i++)      
					    {
						 //  uvw1[i] = uvw1[i] - 2.0*sum2*NN1_[i];
						 //   omega1[i] = omega1[i] - temp2[i]/Ip[i]; 
					    }
				    }
				}
		   }  */

		}  //when there is a cell contact on the wall
	}
	bnlen=Bneighbor.size();
	if(bnlen==0)  goto lab1;
	dist1.resize(bnlen);
	

	for(j=1; j<=Len1; j++)
	{
		for(i=0; i<3; i++)      xyz_beadcenter[i] = xyz_EPS(j,i+1);

		icp_bead=InewTetra(xyz_beadcenter,icp);
		if(icp_bead>0)    bn1=NwallJ(icp_bead,1);
		else              bn1=NwallJ(icp,1);
		if(bn1==0) goto lab2;
		
		Bcenter(bn1,xyz0); 
		Nvec2(bn1,NN1_);
		
		VecMinus(xyz_beadcenter, xyz0, xyz2);
		height2=Dot(NN1_,xyz2);
		if(height2<=0.5*Rbead)
		{

			c_contact++;
			Cross(y2,NN1_,y2NN);
			abc_mag=sqrt(Dot(y2NN,y2NN));
			for(i=0; i<3; i++)   y2NN[i]=y2NN[i]/abc_mag;
        	Cross(y2NN,y2,X1);
			abc_mag=sqrt(Dot(X1,X1));
			for(i=0; i<3; i++)   X1[i]=X1[i]/abc_mag;

			Cross(NN1_,y2NN,TT1_);
			abc_mag=sqrt(Dot(TT1_,TT1_));
			for(i=0; i<3; i++)   TT1_[i]=TT1_[i]/abc_mag;
			Op2_[0]=0.;
	        Op2_[1]=1.;
	        Op2_[2]=0.;	

			if(Dot(y2,NN1_)<=0.) 
			{
				abc_mag=Dot(TT1_,y2);
				if(abc_mag>=1.) abc_mag=1.;
				thetac=acos(abc_mag);
				if(thetac<0.)   thetac=thetac+PI;
			}
			else
			{
				abc_mag=Dot(TT1_,y2);
				if(abc_mag>=1.) abc_mag=1.;
				thetac=acos(abc_mag);
				thetac=2.*PI-thetac;
			}

			cosRa=cos(thetac)/Ra;
			sinRb=sin(thetac)/Rb;
			invRaRb=1./(Ra*Ra)-1./(Rb*Rb);


			xx1=pow((Rb*Rb-Ra*Ra)*sin(thetac)*cos(thetac),2.)*(cosRa*cosRa+sinRb*sinRb);
			yy1=1.+pow((Ra*Rb*invRaRb*sin(thetac)*cos(thetac)),2.);

			if(Dot(y2,NN1_)<=0.)
			{      
				zz1=sqrt(xx1/yy1);
				xx2=-zz1*invRaRb*sin(thetac)*cos(thetac)-sqrt(pow(cosRa,2.) + pow(sinRb,2.) - pow((zz1/Ra/Rb),2.) );
			}
			else
			{   
				zz1=-sqrt(xx1/yy1);
				xx2=-zz1*invRaRb*sin(thetac)*cos(thetac)-sqrt(pow(cosRa,2.) + pow(sinRb,2.) - pow((zz1/Ra/Rb),2.) );
			}

		
			yy2=pow(cosRa,2.)+pow(sinRb,2.);
			zz2=xx2/yy2;

            for(i=0; i<3; i++)
			{
				N_contact1[i]=zz1*TT1_[i]+zz2*NN1_[i];
			}


			
			if(P_shape==Ellipsoid)
			{
			    hc=Dot(NN1_,N_contact1);
				if(hc<0.)
				{
					hc=fabs(hc);
				}
				else
				{
					for(i=0 ;i<3; i++)   N_contact1[i]=-N_contact1[i];
					hc=fabs(Dot(NN1_,N_contact1));
				}
				thetac2=acos(Dot(y2,N_contact1)/sqrt(Dot(N_contact1,N_contact1)));
				if(thetac2 >0.5*PI)  thetac2=PI - thetac2;
				stiff_coef=Spring_force_ellipsoid(Ra, Rb, thetac2);
		
				for(i=0; i<3; i++)
			    {
				   vec_r[i]=N_contact1[i];
			    }
			}
			d2=height2-hc;

			c_contact++;
			for(i=0; i<3; i++)  
			{	   
				xyz_bead_contact[i] = xyz_beadcenter[i] - height2*NN1_[i];
			}
			//VecMinus(xyz_bead_contact,xyz1,vec_r);
			d=r2-height2;
			
			if(d>= delta_max)
			{
				//re_calculation=1;
				delta=delta_max;
			}
			else  delta=d;
		
			for(i=0; i<3; i++) 
			{
				WFrepul_[i]=stiff_coef*pow(delta,1.5)*(NN1_[i]);
			}
			Cross(vec_r,WFrepul_,WTrepul_);
			MatVecProduct(WTrepul_, Tran_A_, WTrepul_, 3, 3); 		
			for(i=0; i<3; i++) 
			{
				Sum_WFrepul_[i]+=WFrepul_[i];
				Sum_WTrepul_[i]+=WTrepul_[i];
			} 
			if(d>repusive_dist_wall)  
			{
				for(i=0; i<3; i++)   xyz1[i]= xyz1[i] + 1.5*d*(NN1_[i]);
			}
			else
			{
				for(i=0; i<3; i++)   xyz1[i]= xyz1[i] + 1.5*d*(NN1_[i]);
			}  
			Make_ellipsoid_in_Solver(pn,xyz1,&epsP2_[0].v[0], y2);
			sum2=0.;
			for(i=0; i<3; i++)   sum2 = sum2 + uvw1[i] * NN1_[i];
			if(sum2<0)
           { 
				for(i=0; i<3; i++)   temp2[i]= Mp*sum2 * NN1_[i];
				Cross(vec_r, temp2, temp1);
				MatVecProduct(temp2, Tran_A_, temp1, 3, 3); 
				if(SLIP==1) 
				{
					for(i=0; i<3; i++)       
					{
						uvw1[i] = uvw1[i] - sum2*NN1_[i];
						omega1[i] = omega1[i] - temp2[i]/Ip[i]; 
					}
				}
				else  
				{
					for(i=0; i<3; i++)      
					{
						uvw1[i] = uvw1[i] - 2.0*sum2*NN1_[i];
						omega1[i] = omega1[i] - temp2[i]/Ip[i]; 
					}
				}
		   }
								
		}
lab2:
		;
	}  

lab1:

	dist1.clear();
	Bneighbor.clear();

	if(c_contact==0) Refulsive_signal=0;
	else             Refulsive_signal=1;
	delete  xyz_bead_bound;
	
	delete  NN2_;
	delete  TT1_;
	delete  TT2_;
	delete  Op2_;
	delete  abc;
	delete  N_contact1;
	delete  N_contact2;
	delete  X1;
	delete  X3;
	delete  udir;
}

/**************************************************************************/
void  GravityForce()
/**************************************************************************/
{
	F_grav_[0]=0.;
    F_grav_[1]=0.;
    F_grav_[2]=-g;
}

double Nwallb(int i, double xyz[])
/**************************************************************************/
{

	double      min1, res;
    int         m, k;
	int      bd, j;


    min1=0.;
	if(Mesh==Tetra)
	{  
		res=1.0e30;
		for(j=1; j<=7; j++)
		{
			bd=NwallJ(i,j);
			if(bd!=0)
			{
				Bcenter(bd, Bcen_);
			    VecMinus(xyz, Bcen_, tmp11_);
			    Nvec2(bd,wallN_);
			    min1=Dot(wallN_,tmp11_);
				res=MIN(min1,res);
			}
		}		
	}

	else
	{
		for(k=1; k<=6; k++)
	    {
			m=cboundJ(i,k);
		    if( m<0 && Bregion(-m)==0)
		    {
				AC(i,k);
			    VecMinus(xyz, Acen_, tmp11_);
			    Nvec(i,k,wallN_);
			    res=Dot(wallN_,tmp11_);
			    break;
		    }
	     }
	}

	return (res);
}
/**************************************************************************/

			
/**************************************************************************/
void  ParticleSeed(int pn, double stime ,double S_slope[],int niter, int Lo)
/**************************************************************************/
{
	double   sum1,del;
	int     i,j,k,Coll_count,m,m1, nv,n,k1;

	double *ss,*vp1,*vp0;
	double y2[3];
	ss=new double[3];
	vp1=new double[3];
	vp0=new double[3];
	
	if(AGAIN==0)
	{
	    for(j=1; j<=MXC; j++)     CellRT_[j-1]=0.;
		bbcount=0;
	    Contact=0;
		cccount=0;
	    Coll_count=0;
	
		TStep(1) = 1.0e-5; //TimeFind(time(1), xyz1, LoPa(1)); 
		for(m=0; m<Nb;m++)    Slope(1,m)=0.;
	}
	
    if(P_shape==Ellipsoid )           
	{
		else      nv=13;
	}
	n=nv*Nb;

	for(m=0; m<Nb;m++)
	{
		for(k=0; k<3; k++)    xyzP1(m,k) = xyzp(1,m,k+1); 
	    for(k=0; k<3; k++)    xyzP0(m,k) = xyzP1(m,k)  - 1.0e-10; 

	    if(Mesh==Tetra)  LoPa(1,m)=InewTetra(&xyzPP1_[m].v1[0], Lo);
	    uvwP1(m,0)=uP(1,m);
        uvwP1(m,1)=vP(1,m);
	    uvwP1(m,2)=wP(1,m);

		uvwP0(m,0)=uP(1,m);
        uvwP0(m,1)=vP(1,m);
	    uvwP0(m,2)=wP(1,m);


        if(P_shape==Ellipsoid )
	    {
		    omP1(m,0)=oX(1,m);
            omP1(m,1)=oY(1,m);
		    omP1(m,2)=oZ(1,m);
			if(AGAIN ==0 )
			{
				eps1_TR(1,m) = eps1;
				eps2_TR(1,m) = eps2;
				eps3_TR(1,m) = eps3;
				eta_TR(1,m)  = eta;
			}
		    epsP1_[m].v[0]=eps1_TR(1,m);
		    epsP1_[m].v[1]=eps2_TR(1,m);
		    epsP1_[m].v[2]=eps3_TR(1,m);
		    epsP1_[m].v[3]=eta_TR(1,m);
			Make_ellipsoid(pn,&xyzPP1_[m].v1[0], &epsP1_[m].v[0],1,&OrienP1(m,0));
		    OrienX(1,m)=OrienP1(m,0);
		    OrienY(1,m)=OrienP1(m,1);
		    OrienZ(1,m)=OrienP1(m,2);    
	    } 

	}
    time(1) = stime;
	Flag = 1 ;	
	AGAIN=0;
	for(i=1; i<=niter; i++)
	{	
		if(Flag)
		{
			 sum1 = TStep(i);
lab1:
		    	
 			RosenStiff2(pn,i,&LoPa(i,0), time(i), TStep(i),mu, uvwP0_,uvwP1_,aP1_,aF1_,tP0_,tP1_,dtP1_,dtFdt1_,alpha_chP1_, xyzPP0_, xyzPP1_,omP1_,epsP1_);
			TStep(i)   = uvxyn(n);
			TStep(i+1) = uvxyn(n+1);    
			for(m=0; m<Nb; m++)
	        {
			    uvwP2(m,0) = uP(i + 1,m) = uvxyn(nv*m+0);  
                uvwP2(m,1) = vP(i + 1,m) = uvxyn(nv*m+1);
			    uvwP2(m,2) = wP(i + 1,m) = uvxyn(nv*m+2);
                xyzP2(m,0) = xP(i + 1,m) = uvxyn(nv*m+3);
                xyzP2(m,1) = yP(i + 1,m) = uvxyn(nv*m+4);
			    xyzP2(m,2) = zP(i + 1,m) = uvxyn(nv*m+5);

				uF(i,m)=uvwF0(m,0);
				vF(i,m)=uvwF0(m,1);
				wF(i,m)=uvwF0(m,2);			
			    if(P_shape==Ellipsoid)
			    { 
				    omP2(m,0) = oX(i + 1,m) = uvxyn(nv*m+6);
                    omP2(m,1) = oY(i + 1,m) = uvxyn(nv*m+7);
			        omP2(m,2) = oZ(i + 1,m) = uvxyn(nv*m+8);
       
				    epsP2_[m].v[0] = eps1_TR(i+1,m) = uvxyn(nv*m+9);
				    epsP2_[m].v[1] = eps2_TR(i+1,m) = uvxyn(nv*m+10);
				    epsP2_[m].v[2] = eps3_TR(i+1,m) = uvxyn(nv*m+11);
				    epsP2_[m].v[3] = eta_TR(i+1,m) = uvxyn(nv*m+12);
				}
			}
			sum1 = TStep(i);
/*----------------------------------------------------------------------------------------------*/
			for(m=0; m<Nb; m++)
	        {
			    if(P_shape==Ellipsoid || P_shape==RBC)
			    { 
				    Make_ellipsoid(pn,&xyzPP2_[m].v1[0], &epsP2_[m].v[0],i+1,&OrienP2_[m].v1[0]);
				    OrienX(i+1,m)=OrienP2(m,0);
		            OrienY(i+1,m)=OrienP2(m,1);
		            OrienZ(i+1,m)=OrienP2(m,2);
			    }
				if(Mesh==Tetra)     
				{
					LoPa(i + 1,m)=InewTetra(&xyzPP2_[m].v1[0], LoPa(i,m));
				}
			}
			
/*----------------------------------------------------------------------------------------------*/	
			for(m=0; m<Nb; m++)
	        {
			    if (LoPa(i+1,m) < 0 && (Bregion(-LoPa(i+1,m) )==0 || Bregion(-LoPa(i+1,m) )==3) ) 
			    {
				    bbcount=bbcount+1;
							
				    if (bbcount>=50*Nb)
				    {
						iPath = i; 
			            TStep(iPath)=200*T;
					    Deposit(LoPa(i,m))=Deposit(LoPa(i,m))+1; 

                        FPLoX(pn,m)= xP(i,m);
					    FPLoY(pn,m)= yP(i,m);
					    FPLoZ(pn,m)= zP(i,m);
					    FPVelU(pn,m) =uP(i,m);  
					    FPVelV(pn,m) =vP(i,m);
					    FPVelW(pn,m) =wP(i,m);
					    DepositP(pn,m)=LoPa(i,m);     /* it gives each chain's location  */

					    if(P_shape==Ellipsoid) 
					    {
							FPox(pn,m)=oX(i,m);
							FPoy(pn,m)=oY(i,m);
							FPoz(pn,m)=oZ(i,m);
						    FPeps1(pn,m)=eps1_TR(i,m);
						    FPeps2(pn,m)=eps2_TR(i,m);
						    FPeps3(pn,m)=eps3_TR(i,m);
						    FPeps4(pn,m)=eta_TR(i,m);
						    Make_ellipsoid_in_Deposition(pn,&FPLo_[pn-1][m].xyz[0], &FPEPS_[pn-1][m].v[0], pn);
					    }
				        goto lab2;
				    }
				    else 
				    {
lab4:
					    TStep(i)=0.7 * TStep(i);
					    goto lab1;
				    }				
				}                                                                     

                else if( Subcset(LoPa(i+1,m))==0 )
			    {
				    iPath = i; 
			        TStep(iPath)=TStep(iPath-1);
					for(m1=0; m1<Nb; m1++)   DepositP(pn,m1)=0;
		            goto lab2; 
			    }    

 /*----------------------------------------------------------------------------------------------*/		
			    if(Mesh==Tetra)
				{
				    if(LoPa(i + 1,m) == LoPa(i,m))  
			        {
					    Flag = 1;
					    if((Nwall(LoPa(i+1,m))!=0 || Nwall2(LoPa(i+1,m))!=0 || Nwall3(LoPa(i+1,m))!=0 || Nwall4(LoPa(i+1,m))!=0 || Nwall5(LoPa(i+1,m))!=0 || Nwall6(LoPa(i+1,m))!=0
						    || Nwall7(LoPa(i+1,m))!=0 ) && TStep(i) < 1.0e-12)       cccount=cccount+1;
					    if(cccount>=500*Nb ) 
					    {
						    iPath = i; 
			                TStep(iPath)=200*T;
						    Deposit(LoPa(i,m))=Deposit(LoPa(i,m))+1; 

							FPLoX(pn,m)= xP(i,m);
					        FPLoY(pn,m)= yP(i,m);
					        FPLoZ(pn,m)= zP(i,m);
					        FPVelU(pn,m) =uP(i,m);  
					        FPVelV(pn,m) =vP(i,m);
					        FPVelW(pn,m) =wP(i,m);
					        DepositP(pn,m)=LoPa(i,m);   /* it gives each chain's location  */
							if(P_shape==Ellipsoid ) 
					        {
								FPox(pn,m)=oX(i,m);
							    FPoy(pn,m)=oY(i,m);
							    FPoz(pn,m)=oZ(i,m);
						        FPeps1(pn,m)=eps1_TR(i,m);
						        FPeps2(pn,m)=eps2_TR(i,m);
						        FPeps3(pn,m)=eps3_TR(i,m);
						        FPeps4(pn,m)=eta_TR(i,m);
						        Make_ellipsoid_in_Deposition(pn,&FPLo_[pn-1][m].xyz[0], &FPEPS_[pn-1][m].v[0], pn);
					        }
							goto lab2;
					    }
			        }
				    else if QcbTetra(LoPa(i+1,m),LoPa(i,m))
			        {
					    Flag = 1;
					    if((Nwall(LoPa(i+1,m))!=0 || Nwall2(LoPa(i+1,m))!=0 || Nwall3(LoPa(i+1,m))!=0 || Nwall4(LoPa(i+1,m))!=0 || Nwall5(LoPa(i+1,m))!=0 || Nwall6(LoPa(i+1,m))!=0
						    || Nwall7(LoPa(i+1,m))!=0 ) && TStep(i) < 1.0e-12)       cccount=cccount+1;
					    if(cccount>=500*Nb ) 
					    {
						    iPath = i; 
			                TStep(iPath)=200*T;
						    Deposit(LoPa(i,m))=Deposit(LoPa(i,m))+1; 

							FPLoX(pn,m)= xP(i,m);
					        FPLoY(pn,m)= yP(i,m);
					        FPLoZ(pn,m)= zP(i,m);
					        FPVelU(pn,m) =uP(i,m);  
					        FPVelV(pn,m) =vP(i,m);
					        FPVelW(pn,m) =wP(i,m);
					        DepositP(pn,m)=LoPa(i,m);   /* it gives each chain's location  */

							if(P_shape==Ellipsoid ) 
					        {
								FPox(pn,m)=oX(i,m);
							    FPoy(pn,m)=oY(i,m);
							    FPoz(pn,m)=oZ(i,m);
						        FPeps1(pn,m)=eps1_TR(i,m);
						        FPeps2(pn,m)=eps2_TR(i,m);
						        FPeps3(pn,m)=eps3_TR(i,m);
						        FPeps4(pn,m)=eta_TR(i,m);
						        Make_ellipsoid_in_Deposition(pn,&FPLo_[pn-1][m].xyz[0], &FPEPS_[pn-1][m].v[0], pn);
					        }
							goto lab2;
					    }
				
				    }
				    else if Qic1Tetra(LoPa(i+1,m),LoPa(i,m))
				    {
					    Flag=1;
					    cccount=0;
			        }
			        else if Qic2Tetra(LoPa(i+1,m),LoPa(i,m))
			        {
					    Flag=1;
					    cccount=0;
			        }
				    else if Qic3Tetra(LoPa(i+1,m),LoPa(i,m))
			        {
					    Flag=1;
					    cccount=0;
			        }
			         else if Qic4Tetra(LoPa(i+1,m),LoPa(i,m))
			        {
				    	Flag=1;
					    cccount=0;
			        }
			        else if Qic5Tetra(LoPa(i+1,m),LoPa(i,m))
			        {
					    Flag=1;
					    cccount=0;
			        }
				    else if Qic6Tetra(LoPa(i+1,m),LoPa(i,m))
			        {
					    Flag=1;
					    cccount=0;
			        }   
				    else 
			        {
lab3:
					    TStep(i)=0.7 * TStep(i);
                        goto lab1;  
				    }   
				}

			}
			
            
			

	for(m=0; m<Nb; m++)
	{
		if ( LoPa(i+1,m) > 0 && (Nwall(LoPa(i+1,m))!=0 || Nwall2(LoPa(i+1,m))!=0 || Nwall3(LoPa(i+1,m))!=0 || Nwall4(LoPa(i+1,m))!=0 || Nwall5(LoPa(i+1,m))!=0
			|| Nwall6(LoPa(i+1,m))!=0 || Nwall7(LoPa(i+1,m))!=0 ))  
		{
			del = Nwallb(LoPa(i+1,m), &xyzPP2_[m].v1[0]);

			if(P_shape==Ellipsoid)
			{
				num_bound = MAX(Ra,Rb);
			}
		    if(del <= num_bound )
			{ 
				    if(Dep==1)
					{
						if(P_shape==Ellipsoid || P_shape==RBC)
						{
							Make_ellipsoid_in_Solver(pn,&xyzPP2_[m].v1[0],&epsP2_[m].v[0], y2); 
							Force_Wall_repulsive4(pn,LoPa(i+1,m),&xyzPP2_[m].v1[0],&uvwP2_[m].v1[0], &uvwF0_[m].v1[0], &omP2_[m].v1[0],y2,TStep(i+1));
							if(re_calculation==1)  
							{
								Refulsive_signal=0;
								goto lab4;
							}
							else if(re_calculation==2) 
							{
								Refulsive_signal=0;
								TStep(i)=1.01 * TStep(i);
								goto lab3;
							}
						}
						else
						{
						    ImageWall(&uvwP2_[m].v1[0], &xyzPP2_[m].v1[0], LoPa(i+1,m), num_bound - del,Rpvar1(pn));
						}
						
						if(Mesh==Tetra)    
						{
							LoPa(i+1,m)=InewTetra( &xyzPP2_[m].v1[0],  LoPa(i,m));
							if(CPIT(LoPa(i + 1,m))==4)
					        {
								LoPa(i + 1,m)=Cell_search(LoPa(i + 1,m), &xyzPP2_[m].v1[0]);
					        }
						}
	                    else            LoPa(i+1,m)=Inew4( &xyzPP2_[m].v1[0],  LoPa(i,m));
						uP(i + 1,m)= uvwP2(m,0);
			            vP(i + 1,m)= uvwP2(m,1);
			            wP(i + 1,m)= uvwP2(m,2);
                        xP(i + 1,m)= xyzP2(m,0);
                        yP(i + 1,m)= xyzP2(m,1);
			            zP(i + 1,m)= xyzP2(m,2);
						if(heat)  
						{
							tempp(i + 1,m)= tP2(m,0);
						    alpha_chp(i + 1,m)=alpha_chP2(m,0);
						}

						if(P_shape==Ellipsoid || P_shape==RBC)
						{
							oX(i + 1,m) = omP2(m,0);
                            oY(i + 1,m) = omP2(m,1);
							oZ(i + 1,m) = omP2(m,2);
							OrienX(i+1,m)=OrienP2(m,0);
		                    OrienY(i+1,m)=OrienP2(m,1);
		                    OrienZ(i+1,m)=OrienP2(m,2);
							eps1_TR(i+1,m)=epsP2_[m].v[0]; 
		                    eps2_TR(i+1,m)=epsP2_[m].v[1]; 
		                    eps3_TR(i+1,m)=epsP2_[m].v[2]; 
		                    eta_TR(i+1,m)=epsP2_[m].v[3]; 
						}
						if (LoPa(i+1,m) < 0 && Bregion(-LoPa(i+1,m) )==0 ) 
			            {	
							iPath = i; 
			                TStep(iPath)=200*T;
							Deposit(LoPa(i,m))=Deposit(LoPa(i,m))+1; 

							FPLoX(pn,m)= xP(i,m);
					        FPLoY(pn,m)= yP(i,m);
					        FPLoZ(pn,m)= zP(i,m);
					        FPVelU(pn,m) =uP(i,m);  
					        FPVelV(pn,m) =vP(i,m);
					        FPVelW(pn,m) =wP(i,m);					
					        DepositP(pn,m)=LoPa(i,m);   /* it gives each chain's location  */
							if(P_shape==Ellipsoid || P_shape==RBC) 
					        {
								FPox(pn,m)=oX(i,m);
							    FPoy(pn,m)=oY(i,m);
							    FPoz(pn,m)=oZ(i,m);
						        FPeps1(pn,m)=eps1_TR(i,m);
						        FPeps2(pn,m)=eps2_TR(i,m);
						        FPeps3(pn,m)=eps3_TR(i,m);
						        FPeps4(pn,m)=eta_TR(i,m);
						        Make_ellipsoid_in_Deposition(pn,&FPLo_[pn-1][m].xyz[0], &FPEPS_[pn-1][m].v[0], pn);
					        }
		                    goto lab2; 
						}
					}		
				}
				else Refulsive_signal=0;
				}
				else   Refulsive_signal=0;
		}
/*----------------------------------------------------------------------------------------------*/			
		time(i + 1) = time(i) + TStep(i);
		for(m=0; m<Nb; m++)   Slope(i+1,m)=Slope(i,m)+sqrt(uP(i,m)*uP(i,m)+vP(i,m)*vP(i,m)+wP(i,m)*wP(i,m))*TStep(i);
     for(m=0; m<Nb; m++)
	 {
        for(k=0; k<3; k++)
		{
			uvwP0(m,k) = uvwP1(m,k);
			uvwP1(m,k) = uvwP2(m,k);
	    	if(P_shape==Ellipsoid)  
			{
				omP1(m,k) = omP2(m,k);	
				OrienP1(m,k)=OrienP2(m,k);
			}
			xyzP0(m,k) = xyzP1(m,k);
            xyzP1(m,k) = xyzP2(m,k);	
		}
		if(P_shape==Ellipsoid)  
		{
			for(k=0; k<4; k++)
			{
				epsP1_[m].v[k]=epsP2_[m].v[k];
			}
		}
		if(m==0)   CellRT(LoPa(i+1,0))+=TStep(i);
	 }

    	if(i==mon_iter){
				out(f,"\n%d:  i = %d , Lopa = %d , timestep = %e \n",id,i,LoPa(i,0),TStep(i));
		}
	
		if( i%freq_out== 0) 
		{
			out(f,"\n%d:  i = %d , Lopa = %d , timestep = %e , Activation = %lf , W = %lf,   Nw = %d\n",id,i,LoPa(i,0),TStep(i), Act(i,0), Weight(i), Nwall(173));
		    out(f2,"\n%d:  i = %d , Lopa = %d , timestep = %e , Activation = %lf , W = %lf,   Nw = %d\n",id,i,LoPa(i,0),TStep(i), Act(i,0), Weight(i), Nwall(173));
		} 

	 for(m=0; m<Nb; m++)
	 {
		if(CellRT(LoPa(i+1,0))>1.0 )  /*  when RT is larger than 1 sec.  */
		{
			iPath = i; 
		    TStep(iPath)=200*T;
			
			Deposit(LoPa(i,m))=Deposit(LoPa(i,m))+1; 
		
					
			FPLoX(pn,m)= xP(i,m);
			FPLoY(pn,m)= yP(i,m);
			FPLoZ(pn,m)= zP(i,m);
			FPVelU(pn,m) =uP(i,m);  
			FPVelV(pn,m) =vP(i,m);
			FPVelW(pn,m) =wP(i,m);		
			DepositP(pn,m)=LoPa(i,m);   /* it gives each chain's location  */
			if(P_shape==Ellipsoid || P_shape==RBC) 
			{
				FPox(pn,m)=oX(i,m);
			    FPoy(pn,m)=oY(i,m);
				FPoz(pn,m)=oZ(i,m);
				FPeps1(pn,m)=eps1_TR(i,m);
				FPeps2(pn,m)=eps2_TR(i,m);
				FPeps3(pn,m)=eps3_TR(i,m);
				FPeps4(pn,m)=eta_TR(i,m);
				Make_ellipsoid_in_Deposition(pn,&FPLo_[pn-1][m].xyz[0], &FPEPS_[pn-1][m].v[0], pn);
			}
			goto lab2;
		}	
	 }

	 if(i==niter)
	 {
		AGAIN=1;
		iPath = i;

		

		for(m=0; m<Nb; m++)
		{	
		    FPLoX(pn,m)= xP(i+1,m);
		    FPLoY(pn,m)= yP(i+1,m);
		    FPLoZ(pn,m)= zP(i+1,m);
		    FPVelU(pn,m) =uP(i+1,m);  
		    FPVelV(pn,m) =vP(i+1,m);
		    FPVelW(pn,m) =wP(i+1,m);
		    DepositP(pn,m)=LoPa(i+1,m);                /* it gives each chain's location  */
		    if(P_shape==Ellipsoid || P_shape==RBC) 
		    {
				FPox(pn,m)=oX(i+1,m);
				FPoy(pn,m)=oY(i+1,m);
				FPoz(pn,m)=oZ(i+1,m);
				FPeps1(pn,m)=eps1_TR(i+1,m);
				FPeps2(pn,m)=eps2_TR(i+1,m);
				FPeps3(pn,m)=eps3_TR(i+1,m);  		
				FPeps4(pn,m)=eta_TR(i+1,m);
		    }   
		}
		goto lab2;
		delete vp0;
		delete vp1;
		delete ss;
	 }
   }
   iPath =i;
lab2:
   ;
	out(f,"\n%d:  i = %d , Lopa = %d , timestep = %e , Activation = %lf\n",id,i,LoPa(i,0),TStep(i), Act(i,0));
	out(f2,"\n%d:  i = %d , Lopa = %d , timestep = %e , Activation = %lf\n",id,i,LoPa(i,0),TStep(i), Act(i,0));
}
/**************************************************************************/
void SaveTrack(double t, int i, int m)
/**************************************************************************/
{
	char s[100];
	int j;

	sprintf(s,"time_%lf_particle_%d_%d.trk", t,i,m);
	ifadev(s)  { 
		out(f,"\n *ERROR-UNABLE TO Write"); 
		exit(1); }
	out(f,"\n time %lf : Particle %d is saving *^^*  \n",t,i);
	out(f2,"\n time %lf : Particle %d is saving *^^*  \n",t,i);
	for(j=1; j<=iPath ; j++)
	{
		if(P_shape==Ellipsoid || P_shape==RBC) 
		{
			out(adev,"%le  %le  %le %d  %le  %e  %le  %le  %e  %e  %e  %e  %e %e  %e  %e %e  %e %e %e %e %e %e %e %e %e\n", 
	        time(j),TStep(j),Slope(j,m),LoPa(j,m),xP(j,m),yP(j,m),zP(j,m),uP(j,m),vP(j,m),wP(j,m),uF(j,m),vF(j,m),wF(j,m),
			oX(j,m),oY(j,m),oZ(j,m),eps1_TR(j,m),eps2_TR(j,m),eps3_TR(j,m),eta_TR(j,m),tempp(j,m), tempF(j,m),
			alpha_chp(j,m), OrienX(j,m), OrienY(j,m), OrienZ(j,m) );
		}
	}
	fclose(adev);
}

/**************************************************************************/
void TecplotMovieGen_BIN(double tstart,double tend, double Mts)
/**************************************************************************/
// Mts mean time step of movie frame, timestep mean timestep of particle motion, t1 means a final time
{
	char s[100], s2[100];
	int i,m,n_frames;
	int kk,Face_count,nps,FaceNodes_count,npis,cbp;
	double tt;

	INTEGER4 Debug,I,J,III,NPts,NElm,NumFaces,DIsDouble,VIsDouble,KMax,FileType,NumFaceNodes;
	INTEGER4 ICellMax, JCellMax, KCellMax, ZoneType;
    INTEGER4 IsBlock, NumFaceConnections, FaceNeighborMode, ShareConnectivityFromZone;
	INTEGER4 StrandID,ParentZone,TotalNumFaceNodes,NumConnBndryFaces,TotalNumBndryConns;
	INTEGER4 npp,SharConn;
	double SolutionTime;

	double  *VX,*VY,*VZ;
	double  *Uv,*Vv,*Wv,*VMAG;
	double  *PHI,*Tv;
	double  *OmX,*OmY,*OmZ;


	VX=new double[MXV];
	VY=new double[MXV];
	VZ=new double[MXV];
	Uv=new double[MXV];
	Vv=new double[MXV];
	Wv=new double[MXV];
	VMAG=new double[MXV];
	PHI=new double[MXV];
	Tv=new double[MXV];
	OmX=new double[MXV];
	OmY=new double[MXV];
	OmZ=new double[MXV];


	n_frames=(int)((tend-tstart)/Mts)+1;
    Mcount_=new int[n_frames];

    sprintf(s,"tecMovie_%lf__%f_BIN.plt",tstart, tend);

    sprintf(s2,"X Y Z");
	if(U_tecplot) strcat(s2," U");
	if(V_tecplot) strcat(s2," V");
	if(W_tecplot) strcat(s2," W");
	if(U_tecplot && V_tecplot && W_tecplot)  strcat(s2," Vmag");
	
	strcat(s2," omegax");
	strcat(s2," omegay");
	strcat(s2," omegaz");
	
	if(T_tecplot) strcat(s2," Temperature");
	strcat(s2," ParticleDiameter");
	
  Debug     = 0;
  VIsDouble = 1;
  FileType = 0;
  I=0;
  
/*
 * Open order.plt and write the header information.
 */
  if(Mesh==Tetra)
  {
	  I = TECINI100("ONE FE-QUAD ZONE",
                s2,
                s,
                ".",
                &Debug,
                &VIsDouble);
	  III = 1;
      I = TECFIL100(&III);
  }
  else if(Mesh==Poly)
  {
	  I = TECINI112("Multiple polyhedral zones", 
		           s2,
                   s,
                   ".",
                   &FileType,
                   &Debug,
                   &VIsDouble);
	
  }
  III = 1;
  I = TECFIL100(&III);
	
  if(Mesh==Tetra)          ZoneType  = 5;    /* FEBRICK */
  else if(Mesh==Poly)      ZoneType  = 7;    /* FEPOLYHEDRON */
  
  NPts      = MXV;  /* Number of points */
  NElm      = MXC;  /* Number of elements */
  NumFaces =Sum_nps;
  KMax      = 0;   /* Unused */

  ICellMax  = 0;
  JCellMax  = 0;
  KCellMax  = 0;

  IsBlock   = 1;
  NumFaceConnections = 0;
  if(Mesh==Tetra)      FaceNeighborMode   = 0;
  else if(Mesh==Poly)  FaceNeighborMode   = 1;
 
  ShareConnectivityFromZone = 0;
  StrandID  = 0;
  SolutionTime = 0.;
  ParentZone   = 0;
  SharConn=0;
  INTEGER4  NFConns    = 0;         /* not used for FEPolyhedron 
                                       * zones 
                                       */
  INTEGER4  FNMode     = 0;         /* not used for FEPolyhedron 
                                       * zones  */

  INTEGER4 *PassiveVarArray = NULL;       
  INTEGER4 *ValueLocArray   = NULL;      
  INTEGER4 *VarShareArray   = NULL;  
  INTEGER4  NumBConns       = 0;   /* No Boundary Connections */
  INTEGER4  NumBItems       = 0;   /* No Boundary Items */
 

  if(Mesh==Tetra)
  {

  I = TECZNE100("Finite Zone",
                &ZoneType,
                &NPts,
                &NElm,
                &KMax,
                &ICellMax,
                &JCellMax,
                &KCellMax,
                &IsBlock,
                &NumFaceConnections,
                &FaceNeighborMode,
                NULL,      /* ValueLocation */
                NULL,      /* ShareVarFromZone */
                &ShareConnectivityFromZone);
/*
 * Write out the field data for the finite-element zone.
 */
  }
  else if(Mesh==Poly)
  {
	  NumFaceNodes=0;
      for(J=1; J<=MXC; J++)
      {
		  npp=N_points_Poly(J);
	      NumFaceNodes+=npp;
      }
	  TotalNumFaceNodes   = NumFaceNodes;
	  NumConnBndryFaces   = 0;
	  TotalNumBndryConns  = 0;
	  I = TECZNE112("Polyhedral Zone (Octahedron)",
                  &ZoneType,                  
                  &NPts,
                  &NElm,
                  &NumFaces,            
                  &ICellMax,                    
                  &JCellMax,                    
                  &KCellMax,                    
                  &SolutionTime,                
                  &StrandID,                    
                  &ParentZone,                 
                  &IsBlock,
                  &NFConns,
                  &FNMode,
                  &TotalNumFaceNodes,
                  &NumBConns,
                  &NumBItems,
                  PassiveVarArray,
                  ValueLocArray,
                  VarShareArray,
                  &SharConn);   
	 
  }



  for(J=1; J<=MXV; J++)
  {
	  VX[J-1]=vertexX(J);
	  VY[J-1]=vertexY(J);
	  VZ[J-1]=vertexZ(J);

    
		  if(U_tecplot)  Uv[J-1]=verU(1,J);
		  if(V_tecplot)  Vv[J-1]=verV(1,J);
		  if(W_tecplot)  Wv[J-1]=verW(1,J);
		  if(U_tecplot && V_tecplot && W_tecplot)  
			  VMAG[J-1]=sqrt(Uv[J-1]*Uv[J-1]+Vv[J-1]*Vv[J-1]+Wv[J-1]*Wv[J-1]);
		
		  OmX[J-1]=0.;
		  OmY[J-1]=0.;
		  OmZ[J-1]=0.;
		 
		  if(T_tecplot)  Tv[J-1]=verT(1,J);
           PHI[J-1]=verT(1,J);
		   
	  
  }


  III       = MXV;
  DIsDouble = 1;


  I    = TECDAT112(&III,VX,&DIsDouble);
  I    = TECDAT112(&III,VY,&DIsDouble);
  I    = TECDAT112(&III,VZ,&DIsDouble);
  if(U_tecplot) {  I    = TECDAT112(&III,Uv,&DIsDouble);  }
  if(V_tecplot) {  I    = TECDAT112(&III,Vv,&DIsDouble);  }
  if(W_tecplot) {  I    = TECDAT112(&III,Wv,&DIsDouble);  }
  if(U_tecplot && V_tecplot && W_tecplot) 
  {  
	  I    = TECDAT112(&III,VMAG,&DIsDouble);  
  }
 
	  I    = TECDAT112(&III,OmX,&DIsDouble);
	  I    = TECDAT112(&III,OmY,&DIsDouble);
	  I    = TECDAT112(&III,OmZ,&DIsDouble);
  

  if(T_tecplot) 
  {  
	  I    = TECDAT112(&III,Tv,&DIsDouble);  
  }
  I    = TECDAT112(&III,PHI,&DIsDouble);
   
  delete VX;
  delete VY;
  delete VZ;
  delete Uv;
  delete Vv;
  delete Wv;
  delete VMAG;
  delete PHI;
  delete Tv;
  delete OmX;
  delete OmY;
  delete OmZ;


  if(Mesh==Tetra)
  {
	  I = TECNOD100(&CELL[0]);
  }
  else if(Mesh==Poly)
  {
	  

      INTEGER4 *FaceNodeCounts = new INTEGER4[NumFaces];
      INTEGER4 *FaceNodes = new INTEGER4[TotalNumFaceNodes];
	  INTEGER4 *FaceLeftElems = new INTEGER4[NumFaces];
      INTEGER4 *FaceRightElems = new INTEGER4[NumFaces];

      Face_count=0;
      for(J=1; J<=MXC; J++)
      {
	      nps=N_Poly_Surf(J);
	      for(i=1; i<=nps; i++)
	      {
		      npis=N_point_in_Surf(J,i);
		      FaceNodeCounts[Face_count]=npis;
			  cbp=cboundJ_poly(J,i);
			  if(cbp<0)  FaceLeftElems[Face_count]=0;
			  else       FaceLeftElems[Face_count]=cbp;
			  FaceRightElems[Face_count]=J;
		      Face_count++;
		  }
	  }
	  FaceNodes_count=0;
	  for(J=1; J<=MXC; J++)
      {
		  npp=N_points_Poly(J);
		  for(i=1; i<=npp; i++)
		  {
			  FaceNodes[FaceNodes_count]=cellJ_poly(J,i);
			  FaceNodes_count++;
		  }
	  }

  
      


  /* Write the face map (created above) using TECPOLY112. */
      I = TECPOLY112(FaceNodeCounts, /* The face node counts array */
                 FaceNodes, /* The face nodes array */
                 FaceLeftElems, /* The left elements array */
                 FaceRightElems, /* The right elements array */
                 NULL, /* No boundary connection counts */
                 NULL, /* No boundary connection elements */
                 NULL); /* No boundary connection zones */
      delete FaceNodeCounts;
      delete FaceNodes;
      delete FaceLeftElems;
      delete FaceRightElems;
  }
   

    for(i=1; i<=n_frames; i++)           /* number of cells in each movie frame was initialized as zero */
	{
		Mcount(i)=0;                           
	}
	

	for(kk=s_time ; kk<=e_time ;kk=kk+1)
	{
		tt = kk * TimeStep;
		for(i=S_P; i<=E_P; i=i+Inc_P)  
	    {
			P_shape=celltype(i);
			if(P_shape==Ellipsoid || P_shape==RBC)
			{
				Nb=1;
			}
			else if(P_shape==DNA)
			{
				Nb=40;
			}
			else   // sphere
			{
				Nb=1;
			}
			for(m=0; m<Nb; m++)   
			{
				ReadTrack2_DET( tt,tstart, tend,i,m, Mts);
			}
	

		}
	}
	


	for(kk=1; kk<=n_frames; kk++)
	{		
	    PathGen2_bin(kk, Mcount(kk));
	}

	if(Mesh==Tetra)       I = TECEND100(); 
	else if(Mesh==Poly)   I = TECEND112();

	
    delete Mcount_;
	
}
/**************************************************************************/
void  PathGen_bin(int ipath, int m)
/**************************************************************************/
{
	
	

	INTEGER4 I,J,III,DIsDouble,IMax,JMax,KMax;
    INTEGER4 ICellMax, JCellMax, KCellMax, ZoneType;
    INTEGER4 IsBlock, NumFaceConnections, FaceNeighborMode, ShareConnectivityFromZone;

	double *XP,*YP,*ZP;
	double *UP,*VP,*WP,*MAGP,*TEMPP,*PType, *omXP,*omYP,*omZP;


	IMax      = ipath;
    CreateVector(&XP,ipath);
	CreateVector(&YP,ipath);
	CreateVector(&ZP,ipath);
	CreateVector(&UP,ipath);
	CreateVector(&VP,ipath);
	CreateVector(&WP,ipath);
	CreateVector(&MAGP,ipath);
	CreateVector(&TEMPP,ipath);
	omXP=new double[IMax];
	omYP=new double[IMax];
	omZP=new double[IMax];
	PType=new double[IMax];



  III = 1;
  I = TECFIL100(&III);

  
  JMax      = 1;
  KMax      = 1;
  ICellMax  = 0;
  JCellMax  = 0;
  KCellMax  = 0;
  ZoneType  = 0;
  IsBlock   = 1;
  NumFaceConnections = 0;
  FaceNeighborMode   = 0;
  ShareConnectivityFromZone = 0;
  I = TECZNE100("Streamtrace",
                &ZoneType,
                &IMax,
                &JMax,
                &KMax,
                &ICellMax,
                &JCellMax,
                &KCellMax,
                &IsBlock,
                &NumFaceConnections,
                &FaceNeighborMode,
                NULL,      /* ValueLocation */
                NULL,      /* ShareVarFromZone */
                &ShareConnectivityFromZone);


  for(J=1; J<=ipath; J++)
  {
	  XP[J-1]=xP(J,m);
	  YP[J-1]=yP(J,m);
	  ZP[J-1]=zP(J,m);
	  UP[J-1]=uP(J,m);
	  VP[J-1]=vP(J,m);
	  WP[J-1]=wP(J,m);
	  MAGP[J-1]=sqrt(uP(J,m)*uP(J,m)+vP(J,m)*vP(J,m)+wP(J,m)*wP(J,m));
	  TEMPP[J-1]=tempp(J,m);

	  if(P_shape==Ellipsoid || P_shape==RBC) 
	  {
		  omXP[J-1]=oX(J,m);
		  omYP[J-1]=oY(J,m);
		  omZP[J-1]=oZ(J,m);
	//	  MorientX_[J-1]=OrienX(J);
	//	  MorientY_[J-1]=OrienY(J);
	//	  MorientZ_[J-1]=OrienZ(J);
         PType[J-1]=0.56667e-6;
	  }
	  else if(P_shape==DNA)
	  {
		  PType[J-1]=0.0457078e-6;
	  }
  }


  DIsDouble = 1;
  III = IMax;
  I   = TECDAT100(&III,&XP[0],&DIsDouble);
  I   = TECDAT100(&III,&YP[0],&DIsDouble);
  I   = TECDAT100(&III,&ZP[0],&DIsDouble);
  I   = TECDAT100(&III,&UP[0],&DIsDouble);
  I   = TECDAT100(&III,&VP[0],&DIsDouble);
  I   = TECDAT100(&III,&WP[0],&DIsDouble);
  I   = TECDAT100(&III,&MAGP[0],&DIsDouble);
  if(P_shape==Ellipsoid || P_shape==RBC)  
  {
	  I   = TECDAT100(&III,&omXP[0],&DIsDouble);
	  I   = TECDAT100(&III,&omYP[0],&DIsDouble);
	  I   = TECDAT100(&III,&omZP[0],&DIsDouble);
	//  I   = TECDAT100(&III,&MorientX_[0],&DIsDouble);
	//  I   = TECDAT100(&III,&MorientY_[0],&DIsDouble);
	//  I   = TECDAT100(&III,&MorientZ_[0],&DIsDouble);
  }
  I   = TECDAT100(&III,&TEMPP[0],&DIsDouble);
  I   = TECDAT100(&III,&PType[0],&DIsDouble);

    DeleteVector(&XP);
	DeleteVector(&YP);
	DeleteVector(&ZP);
	DeleteVector(&UP);
	DeleteVector(&VP);
	DeleteVector(&WP);
	DeleteVector(&MAGP);
	DeleteVector(&TEMPP);
	delete PType;
	delete omXP;
	delete omYP;
	delete omZP;

}

/**************************************************************************/
  void tecMacro_MakeMovie(int i)
/**************************************************************************/
{
  int k;   
  char drtry0[250], drtry[250];
  
  getcwd(drtry0,250);
  getcwd(drtry,250);
  strcat(drtry,"\\export.avi");
  
  wdev=fopen("movie.mcr","w");
  out(wdev,"#!MC 1120\n");
  out(wdev,"# Created by Tecplot 360 build 11.2-0-563\n");

  
  out(wdev,"$!VarSet |MFBD| = '%s'\n",drtry0);
  out(wdev,"$!ACTIVEFIELDMAPS += [1]\n");
  out(wdev,"$!ACTIVEFIELDMAPS += [2]\n");
  out(wdev,"$!EXPORTSETUP EXPORTFORMAT = AVI\n");
  out(wdev,"$!EXPORTSETUP IMAGEWIDTH = 859\n");
  out(wdev,"$!EXPORTSETUP SUPERSAMPLEFACTOR = 5\n");
  out(wdev,"$!EXPORTSETUP EXPORTFNAME = \'%s\'\n", drtry);
  out(wdev,"$!EXPORTSTART \n");
  out(wdev,"   EXPORTREGION = CURRENTFRAME \n");
  for(k=2; k<=i; k++)
  {
	  out(wdev,"$!ACTIVEFIELDMAPS -= [%d]\n",k);
      out(wdev,"$!ACTIVEFIELDMAPS += [%d]\n",k+1);
 //     out(wdev,"$!REDRAW \n");
      out(wdev,"$!EXPORTNEXTFRAME \n");
  }
  out(wdev,"$!EXPORTFINISH \n");
  out(wdev,"$!RemoveVar |MFBD|\n");

  fclose(wdev);

}
/**************************************************************************/
  void tecMacro_MakeFlash(int i)
/**************************************************************************/
{
  int k;   
  char drtry0[250], drtry[250];
  
  getcwd(drtry0,250);
  getcwd(drtry,250);
  strcat(drtry,"\\export_");
  
  wdev=fopen("flash.mcr","w");

  out(wdev,"#!MC 1120 \n");
  out(wdev,"# Created by Tecplot 360 build 11.2-0-563 \n");
  out(wdev,"$!VarSet |MFBD| ='%s'\n",drtry0);
  out(wdev,"#$!ACTIVEFIELDZONES += [1]\n");
  out(wdev,"#$!ACTIVEFIELDZONES += [2]\n");
  out(wdev,"$!REDRAW \n");
  out(wdev,"$!EXPORTSETUP EXPORTFORMAT = PNG\n");
  out(wdev,"$!EXPORTSETUP IMAGEWIDTH = 1000\n");
  out(wdev,"$!EXPORTSETUP EXPORTFNAME = \'%s1.png\'\n", drtry);
  out(wdev,"$!EXPORT\n"); 
  for(k=2; k<=i; k++)
  {
	  out(wdev,"$!ACTIVEFIELDZONES -= [%d]\n",k);
      out(wdev,"$!ACTIVEFIELDZONES += [%d]\n",k+1);
      out(wdev,"$!REDRAW \n");
	  out(wdev,"$!EXPORTSETUP EXPORTFNAME = \'%s%d.png\'\n", drtry,k);
      out(wdev,"$!EXPORT\n"); 
 
  }

  out(wdev,"$!RemoveVar |MFBD|\n");

  fclose(wdev);

}





/**************************************************************************/
  void skip_(int nline)
/**************************************************************************/
{
  int i;   

  for(i=1; i <= nline; i++) fgets(str,100,rdev); 
}
/**************************************************************************/
double Vmag(double t, double xyz[], int l)
/**************************************************************************/
  {
 	  double  mag;
	  
	
	  if(TempInt==0)   CubicInter1(l, t, xyz, uvwFtm_, Fm1_);
	  else             LinearInter0(l, t, xyz, uvwFtm_, Fm1_);
	  mag=sqrt(Dot(uvwFtm_,uvwFtm_));
	 
	
	  return mag;
	
  }
/**************************************************************************/
double gasdev(int *idum)
/**************************************************************************/
{
	
	double fac_g,rsq_g,v1_g,v2_g;


	if (*idum <0)   iset=0;
	if (iset == 0) 
	{
		do
		{ 
			v1_g=2.0*ran1(idum)-1.0;
			v2_g=2.0*ran1(idum)-1.0;
			rsq_g=v1_g*v1_g+v2_g*v2_g;
		} while (rsq_g >= 1.0 || rsq_g ==0.0);
		fac_g=sqrt(-2.0*log(rsq_g)/rsq_g);
		gset=v1_g*fac_g;
		iset=1;
		return v2_g*fac_g;
	}
	else
	{
		iset=0;
		return  gset;
	}
}



/**************************************************************************/
double   gaussrand() 
/**************************************************************************/
{ 
static double V1, V2, S; 
static int phase = 0; 
double X; 

if(phase == 0) 
{ 
	do 
	{ 
        double U1 = (double)rand() / RAND_MAX; 
        double U2 = (double)rand() / RAND_MAX; 

        V1 = 2 * U1 - 1; 
        V2 = 2 * U2 - 1; 
        S = V1 * V1 + V2 * V2; 
	} while(S >= 1 || S == 0); 

    X = V1 * sqrt(-2 * log(S) / S); 
} 
else    X = V2 * sqrt(-2 * log(S) / S); 

phase = 1 - phase; 

return X; 
} 

/**************************************************************************/
void Make_gaussdev()
/**************************************************************************/
{
	long idum1;
	int i;

	idum1=-1;
	for(i=0; i<30000; i++)
	{
		GD[i]=gaussrand();
	}
}



/**************************************************************************/
void Ellipsoid_Brownian_Motion(int lp,double xyz1[],double y2[], double delt, double rp)
/**************************************************************************/
{

	double Dxx,Dyy,Dzz;
	double sigma[3];
	long idum1,idum2,idum3;
    double dxyz[3];
	int k,bn,j,lp1;
	double xyz0[3], NN_[3],Fbrown_NN[3],xyz3[3];
	double len1, height,FBro,r1,hc;

    
	idum1=-1;
	idum2=-1;
	idum3=-1;

//	Dxx=2.*Kb*Tm*Kxx/delt;
//	Dyy=2.*Kb*Tm*Kyy/delt;
//	Dzz=2.*Kb*Tm*Kzz/delt;

	Dxx=Kb*Tm/(Kxx*PI*rp*mu);
	Dyy=Kb*Tm/(Kyy*PI*rp*mu);
	Dzz=Kb*Tm/(Kzz*PI*rp*mu);

	sigma[0]=sqrt(2.*Dxx*delt);
	sigma[1]=sqrt(2.*Dyy*delt);
	sigma[2]=sqrt(2.*Dzz*delt); 

/*	Dxx=Kb*Tm*(Kxx*PI*R*mu);
	Dyy=Kb*Tm*(Kyy*PI*R*mu);
	Dzz=Kb*Tm*(Kzz*PI*R*mu);

	sigma[0]=sqrt(2.*Dxx/delt);
	sigma[1]=sqrt(2.*Dyy/delt);
	sigma[2]=sqrt(2.*Dzz/delt);  */ 

	//rn1=(int) RandomRange(29999.);
	
	dxyz[0]=sigma[0]*GD[Brown_c];
	//rn1=(int) RandomRange(29999.);
	dxyz[1]=sigma[1]*GD[Brown_c+10000];
	//rn1=(int) RandomRange(29999.);
	dxyz[2]=sigma[2]*GD[Brown_c+20000];

	
	/*for(j=0; j<3; j++)
	{
		rm=uniform01()-0.5;
        dxyz[j]=rm*sigma[j];
	}   */

/*	dxyz[0]=0.;
	dxyz[1]=0.;
	dxyz[2]=0.;*/
	

	MatVecProduct(&F_Brown_[0].v1[0], ITran_A_, dxyz, 3, 3); 

	FBro=sqrt(Dot(&F_Brown_[0].v1[0],&F_Brown_[0].v1[0]));
	if(FBro>rp)
	{
		for(j=0; j<3; j++)  Fbrown_NN[j]=F_Brown_[0].v1[j]/FBro;
		for(j=0; j<3; j++)  F_Brown_[0].v1[j]=rp*Fbrown_NN[j];
	}
	for(j=0; j<3; j++)    xyz3[j]=xyz1[j] + F_Brown_[0].v1[j];
	lp1=InewTetra(xyz3,lp);
	if( lp1 <0) 
	{
		for(j=0; j<3; j++)     F_Brown_[0].v1[j]=-F_Brown_[0].v1[j];
		goto lab1;
	}

	if ( lp > 0 && (Nwall(lp)!=0 || Nwall2(lp)!=0 || Nwall3(lp)!=0 || Nwall4(lp)!=0 || Nwall5(lp)!=0
			|| Nwall6(lp)!=0 || Nwall7(lp)!=0 ))  
	{
		for(k=1;k<=7;k++)
	    {
			bn=NwallJ(lp,k);
		    if(bn==0) break;
			else
		    {
				Bcenter(bn,xyz0);
				Nvec2(bn,NN_);

				VecMinus(xyz1, xyz0, xyz3);
			    height=Dot(NN_,xyz3);
			    r1=rp;

				hc=fabs(rp*Dot(NN_,y2));

			    if(height<r1 || height< hc)    
			    {
					len1=Dot(&F_Brown_[0].v1[0],NN_);
				    if(len1<0.)
				    {
					    for(j=0; j<3; j++)   F_Brown_[0].v1[j]=-len1*NN_[j];
				    }
		
				}  
			}
		}
	}  
lab1:
	;
}

/**************************************************************************/
void Ellipsoid_Brownian_Motion2(int m, double delt, double temp1)
/**************************************************************************/
{

	double Dxx,Dyy,Dzz;
	double sigma[3];
	long idum1,idum2,idum3;
    double dxyz[3];



    
	idum1=-1;
	idum2=-1;
	idum3=-1;


	Dxx=2.*Kb*temp1/(Kxx*PI*R*mu);
	Dyy=2.*Kb*temp1/(Kyy*PI*R*mu);
	Dzz=2.*Kb*temp1/(Kzz*PI*R*mu);

	sigma[0]=sqrt(Dxx/delt);
	sigma[1]=sqrt(Dyy/delt);
	sigma[2]=sqrt(Dzz/delt); 

	dxyz[0]=sigma[0]*GD[Brown_c];
	dxyz[1]=sigma[1]*GD[Brown_c+10000];
	dxyz[2]=sigma[2]*GD[Brown_c+20000];
/*	for(j=0; j<3; j++)
	{
		rm=uniform01()-0.5;
        dxyz[j]=rm*sigma[j];
	}	*/

	MatVecProduct(&F_Brown_[m].v1[0], ITran_A_, dxyz, 3, 3); 
}


/**************************************************************************/
double RandomRange(double dx)
/**************************************************************************/
{
	double v1,rn;

	int idum;
    
	idum=-1;
	for(;;)
	{

		v1=dx*ran1(&idum);
		
	    rn=v1;
	    if(rn>0. && rn<dx)  break;
	}
  
   return rn;
}
/**************************************************************************/
double RandomRange2(double dx0, double dx)
/**************************************************************************/
{
	double v1, rn;

	int idum;
    
	idum=-1;
	for(;;)
	{
		v1=(dx-dx0)*ran1(&idum)+dx0;
	
	    rn=v1;
	    if(rn>dx0 && rn<dx)  break;
	}
  
   return rn;
}
/**************************************************************************/
void RandomSeed(int i, int set)
/**************************************************************************/
{
	int  j,k, n;
	int m;
    double  max[3], min[3], pn;
  

	pn=3.0e14;
//    n=(int)(VolC(i)*pn);
//	if(n==0) n=1;
    n=1;
	for(k=0; k<8; k++)
	{
		m=cellJ(i,k+1);
		for(j=0; j<3; j++)   
		{
			VXYZ(k,j)=vertex(m,j+1);
			max[j]=smallest;
			min[j]=great;
		}
	}
	
	for(k=0; k<8; k++)
	{
		for(j=0; j<3; j++)
		{
			max[j]=MAX(max[j], VXYZ(k,j));
		    min[j]=MIN(min[j], VXYZ(k,j));
		}
	}
	for(j=sn; j<=sn+n-1; j++)
	{
		for(k=0; k<3; k++) 	Seed_[j].v[k] = min[k] + RandomRange( fabs(max[k]-min[k]) );
	}
	sn=sn+n;
	

}

/**************************************************************************/
void ReadTrack_DET(double t, double te, int i, int m)
/**************************************************************************/
{
	int k,n;
	double  t2;

	k=(int)(RoundOff(t/TimeStep));
	n=(int)(RoundOff(T/TimeStep));

	
	
	t2=(double)((k%n)*TimeStep);

	sprintf(jobtemp,"time_%lf_particle_%d_%d.trkb", t2,i,m);

	ifrbdev(jobtemp) 
	{ 
		sprintf(jobtemp,"time_%lf_particle_%d.trk", t2,i);
		ifrdev(jobtemp) 
	    { 
			out(f,"\n *ERROR-UNABLE TO OPEN %s", jobtemp); goto lab1; 
		}
		else
		{
		    if(i%1==0) out(f,"\n time: %lf LOADING PROBLEM  DATA FROM FILE %s\n", t,jobtemp);
			ReadTrack(t,te,i,m);
			goto lab1; 
		}
	}
    else  
	{
	    if(i%1==0) out(f,"\n time: %lf LOADING PROBLEM  DATA FROM FILE %s\n", t,jobtemp);
		ReadTrack_BIN(t,te,i,m);
	}

lab1:
	;


}
/**************************************************************************/
void ReadTrack_Ellipsoid_DET(double t, double te, int i, int j)
/**************************************************************************/
{
	int k,n;
	
	double  t2;
	k=(int)(RoundOff(t/TimeStep));
	n=(int)(RoundOff(T/TimeStep));
	t2=(double)((k%n)*TimeStep);
	sprintf(jobtemp,"time_%lf_particle_%d_%d.trkb", t2,i,j);

	ifrbdev(jobtemp) 
	{ 
		sprintf(jobtemp,"time_%lf_particle_%d_%d.trk", t2,i,j);
		ifrdev(jobtemp) 
	    { 
			out(f,"\n *ERROR-UNABLE TO OPEN %s", jobtemp); goto lab1; 
		}
		else
		{
		    if(i%1==0) out(f,"\n time: %lf LOADING PROBLEM  DATA FROM FILE %s\n", t,jobtemp);
			ReadTrack1_Ellipsoid(t,te,i,j);
			goto lab1; 
		}
	}
    else  
	{
	    if(i%1==0) out(f,"\n time: %lf LOADING PROBLEM  DATA FROM FILE %s\n", t,jobtemp);
		ReadTrack1_Ellipsoid_BIN(t,te,i,j);
	}

lab1:
	;


}
/**************************************************************************/
void ReadTrack_Restart(double t, int i,int m)
/**************************************************************************/
{

	int j,j1, k, n, kk,js;
	double  t2;
	char *empty="";
	k=(int)(RoundOff(t/TimeStep));
	n=(int)(RoundOff(T/TimeStep));
	t2=(double)((k%n)*TimeStep);
    kk=k%2+1;
	sprintf(jobtemp,"time_%lf_particle_%d_%d.trk", t2,i,m);
	ifrdev(jobtemp) { out(f,"\n *ERROR-UNABLE TO OPEN %s", jobtemp); goto lab1; }
    else  
	{
		if(i%1==0) out(f,"\n time: %lf LOADING PROBLEM  DATA FROM FILE %s\n", t,jobtemp);
	}   
    js=1;
lab3:

	for(j1=js; ;j1++ )
	{
        if(j1%MaxIter==0) j=MaxIter;
		else              j=j1%MaxIter;
		if(P_shape==Ellipsoid ) fscanf(rdev,"%lf  %lf  %lf  %d  %lf  %lf  %lf  %lf  %lf  %lf  %lf %lf  %lf  %lf  %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf\n",
			&time(j),&TStep(j),&Slope(j,m),&LoPa(j,m),&xP(j,m),&yP(j,m),&zP(j,m),&uP(j,m),&vP(j,m),&wP(j,m),&uF(j,m),&vF(j,m),&wF(j,m),
			&oX(j,m),&oY(j,m),&oZ(j,m),&eps1_TR(j,m), &eps2_TR(j,m),&eps3_TR(j,m),&eta_TR(j,m),&tempp(j,m),&tempF(j,m),&OrienX(j,m), &OrienY(j,m), &OrienZ(j,m) );


		if(TStep(j)<-10000000000.)  
		{
			printf(" timestep warning  \n");
		}
		if(j1%MaxIter==0)  
		{
			iPath=j-1;
			if(feof(rdev))  
		    {
			    break;
			}
			else
			{
			    js=j1+1;
			    goto lab3;
			}
		}


		if(feof(rdev))  
		{
			iPath=j-1;
			break;
		}
	}
	fclose(rdev);
	

	AGAIN=1;
		
	FPLoX(i,m)= xP(iPath+1,m);
	FPLoY(i,m)= yP(iPath+1,m);
	FPLoZ(i,m)= zP(iPath+1,m);
	FPVelU(i,m) =uP(iPath+1,m);  
	FPVelV(i,m) =vP(iPath+1,m);
	FPVelW(i,m) =wP(iPath+1,m);
	DepositP(i,m)=LoPa(iPath+1,m);   /* it gives each chain's location  */
	if(P_shape==Ellipsoid || P_shape==RBC) 
	{
		FPeps1(i,m)=eps1_TR(iPath+1,m);
		FPeps2(i,m)=eps2_TR(iPath+1,m);
		FPeps3(i,m)=eps3_TR(iPath+1,m);
		FPeps4(i,m)=eta_TR(iPath+1,m);
	} 
	TStep(1) = TStep(iPath+1);	
lab1:
	;
}

/**************************************************************************/
void ReadTrack1_Ellipsoid(double t, double te, int i, int m)
/**************************************************************************/
{

	int j;

 
	for(j=1; ;j++ )
	{
		fscanf(rdev,"%lf  %lf  %d  %lf  %lf  %lf\n",&time0(j),&TStep(j),&LoPa(j,m),&xP(j,m),&yP(j,m),&zP(j,m));
	    

		if(TStep(j)<-10000000000.)  
		{
			printf(" timestep warning  \n");
		}


		if(feof(rdev))  
		{
			iPath=j;
			break;
		}
	}
	fclose(rdev);
}

/**************************************************************************/
void ReadTrack2(double t, double tstart,double tend, int i, int m,double Mts)
/**************************************************************************/
{

	int j,j1, n, kk,nT, dd, js, flag, kk_count, kk0;
	int cc, k,  endk, newiPath,n_frames;
	
	double   tau;

	n_frames=(int)((tend-tstart)/Mts)+1;

	Mxyz_=new typeseed2[n_frames];
    Muvw_=new typeseed2[n_frames];

	
		MomegaX_=new double[n_frames];
        MomegaY_=new double[n_frames];
        MomegaZ_=new double[n_frames];
        Meps1P_=new double[n_frames];
        Meps2P_=new double[n_frames];
        Meps3P_=new double[n_frames];
        MetaP_=new double[n_frames];
	
    McellType_=new int[n_frames];
    Mtime_=new double[n_frames];
	Mtime0_=new double[n_frames];



	

	flag=0;

	k=(int)(RoundOff(t/TimeStep));
	n=(int)(RoundOff(T/TimeStep));
	
	nT=(int)(RoundOff((tend-tstart)/T));
	P_shape=celltype(i);
	
//	t2=(double)((k%n)*TimeStep);
	

/*	sprintf(jobtemp,"time_%lf_particle_%d.trk", t2,i);
	ifrdev(jobtemp) { out(f,"\n *ERROR-UNABLE TO OPEN %s", jobtemp); goto lab2; }
    else  
	{
		if(i%1==0) out(f,"\n time: %lf LOADING PROBLEM  DATA FROM FILE %s\n", t,jobtemp);
	}    */

	js=1;
	kk0=0;
	kk_count=0;
 
lab4:
	for(j1=js; ;j1++ )
	{
        if(j1%MaxIter==0) j=MaxIter;
		else              j=j1%MaxIter;
		if(P_shape==Ellipsoid || P_shape==RBC) fscanf(rdev,"%lf  %lf  %lf  %d  %lf  %lf  %lf  %lf  %lf  %lf  %lf  %lf  %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf\n",
			&time0(j),&TStep(j),&Slope(j,m),&LoPa(j,m),&xP(j,m),&yP(j,m),&zP(j,m),&uP(j,m),&vP(j,m),&wP(j,m),&uF(j,m),&vF(j,m),&wF(j,m),
			&oX(j,m),&oY(j,m),&oZ(j,m),&eps1_TR(j,m), &eps2_TR(j,m),&eps3_TR(j,m),&eta_TR(j,m),&tempp(j,m),&tempF(j,m),&alpha_chp(j,m),&OrienX(j,m), &OrienY(j,m), &OrienZ(j,m));
	    else  fscanf(rdev,"%lf %lf %lf %d %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf\n",
			&time0(j),&TStep(j),&Slope(j,m),&LoPa(j,m),&xP(j,m),&yP(j,m),&zP(j,m),&uP(j,m),&vP(j,m),&wP(j,m),&uF(j,m),&vF(j,m),&wF(j,m),
			&tempp(j,m),&tempF(j,m),&alpha_chp(j,m),&Act(j,m), &Weight(j));


		if(TStep(j)<-10000000000.)  
		{
			printf(" timestep warning  \n");
		}
		if(j1%MaxIter==0)  
		{
			iPath=j;
			if(feof(rdev))  
		    {
				flag=1;
			    break;
			}
			else
			{
			    js=j1+1;
			    goto lab3;
			}
		}


		if(feof(rdev))  
		{
			iPath=j;
			flag=1;
			break;
		}
	}
	fclose(rdev);

lab3:
	cc=1;
	newiPath=0;
	
	for(kk=1; kk<=n_frames ; kk++)              // 다시 시간 단위로 재 배열
	{
		Mtime0(kk) = tstart + Mts*(kk-1);
		for(j=cc; j<=iPath-1; j++)
		{
			if((Mtime0(kk)  >= time0(j)) && (Mtime0(kk)  < time0(j+1)))
			{
				kk_count++;
				if(kk_count==1) 
				{
					kk0=kk;
				}
                cc=j;
				
				
				tau= (Mtime0(kk) - time0(j))/(time0(j+1) - time0(j));
				MxP(kk) = tau*xP(j+1,m) + (1.-tau)*xP(j,m);
				MyP(kk) = tau*yP(j+1,m) + (1.-tau)*yP(j,m);
				MzP(kk) = tau*zP(j+1,m) + (1.-tau)*zP(j,m);
				if(MzP(kk)>=10000) 
				{
					printf(" error \n");
				}
				MuP(kk) = tau*uP(j+1,m) + (1.-tau)*uP(j,m);
				MvP(kk) = tau*vP(j+1,m) + (1.-tau)*vP(j,m);
				MwP(kk) = tau*wP(j+1,m) + (1.-tau)*wP(j,m);
				if(P_shape==Ellipsoid || P_shape==RBC)
				{
					MoxP(kk) = tau*oX(j+1,m) + (1.-tau)*oX(j,m);
					MoyP(kk) = tau*oY(j+1,m) + (1.-tau)*oY(j,m);
					MozP(kk) = tau*oZ(j+1,m) + (1.-tau)*oZ(j,m);

					Meps1P(kk) = tau*eps1_TR(j+1,m) + (1.-tau)*eps1_TR(j,m);
					Meps2P(kk) = tau*eps2_TR(j+1,m) + (1.-tau)*eps2_TR(j,m);
					Meps3P(kk) = tau*eps3_TR(j+1,m) + (1.-tau)*eps3_TR(j,m);
					MetaP(kk) =  tau*eta_TR(j+1,m)  + (1.-tau)*eta_TR(j,m);

				}
				else
				{
					MoxP(kk) = 0.;
					MoyP(kk) = 0.;
					MozP(kk) = 0.;

					Meps1P(kk) = 0.;
					Meps2P(kk) = 0.;
					Meps3P(kk) = 0.;
					MetaP(kk) =  0.;

				}
				MtempP(kk) = tau*tempp(j+1,m) + (1.-tau)*tempp(j,m);
	//			MPT(kk) = Ptype(i);
				Mcelltype(kk)=i;
				if(P_shape==Ellipsoid) 
				{
					MPT(kk) =0.56667e-6; 
					
				}
				else if(P_shape==RBC)  
				{
					MPT(kk) =2.*0.56667e-6;
				
				}
				else          
				{
					MPT(kk) = 2.*Rpvar1(i);
				
				}
				newiPath=kk-1;
				if(j==iPath-1 && Mtime0(kk)  < time0(iPath) )   goto lab1;
				else     break;
				
			}
			else if(Mtime0(kk)  >= time0(iPath) && Mtime0(kk)  <= tend)
			{
				if(TStep(iPath) > 100*T)
				{
					cc=iPath-1;  
				    MxP(kk) = xP(iPath,m) ;
				    MyP(kk) = yP(iPath,m) ;
				    MzP(kk) = zP(iPath,m) ;
				    if(MzP(kk)>=10000) 
				    {
						printf(" error \n");
				    }
			    	MuP(kk) = uP(iPath,m);
			    	MvP(kk) = vP(iPath,m);
			    	MwP(kk) = wP(iPath,m);
					if(P_shape==Ellipsoid || P_shape==RBC)
			     	{
					   MoxP(kk) = oX(iPath,m);
					   MoyP(kk) = oY(iPath,m);
					   MozP(kk) = oZ(iPath,m);

					   Meps1P(kk) = eps1_TR(iPath,m);
					   Meps2P(kk) = eps2_TR(iPath,m);
					   Meps3P(kk) = eps3_TR(iPath,m);
					   MetaP(kk) =  eta_TR(iPath,m);

				    }
					else
					{
						MoxP(kk) = 0.;
					    MoyP(kk) = 0.;
					    MozP(kk) = 0.;

					    Meps1P(kk) = 0.;
					    Meps2P(kk) = 0.;
					    Meps3P(kk) = 0.;
					    MetaP(kk) =  0.;
					}
		  //   		MPT(kk) = Ptype(i);
					MtempP(kk) =tempp(iPath,m);
					Mcelltype(kk)=i;
		    		if(P_shape==Ellipsoid) 
					{
						MPT(kk) =0.56667e-6;  
				
					}
				    else if(P_shape==RBC)  
					{
						MPT(kk) =2.*0.56667e-6;
				
					}
					else          
					{
						MPT(kk) = 2.*Rpvar1(i);
				
					}
		    		newiPath=kk-1;
		    		break;
				}
				else
				{
					MxP(kk) = xP(iPath,m) ;
				    MyP(kk) = yP(iPath,m) ;
				    MzP(kk) = zP(iPath,m) ;
				 
			    	MuP(kk) = uP(iPath,m);
			    	MvP(kk) = vP(iPath,m);
			    	MwP(kk) = wP(iPath,m);
//		     		MPT(kk) = Ptype(i);
					if(P_shape==Ellipsoid || P_shape==RBC)
			     	{
					   MoxP(kk) = oX(iPath,m);
					   MoyP(kk) = oY(iPath,m);
					   MozP(kk) = oZ(iPath,m);

					   Meps1P(kk) = eps1_TR(iPath,m);
					   Meps2P(kk) = eps2_TR(iPath,m);
					   Meps3P(kk) = eps3_TR(iPath,m);
					   MetaP(kk) =  eta_TR(iPath,m);
				    }
					else
					{
						MoxP(kk) = 0.;
					    MoyP(kk) = 0.;
					    MozP(kk) = 0.;

					    Meps1P(kk) = 0.;
					    Meps2P(kk) = 0.;
					    Meps3P(kk) = 0.;
					    MetaP(kk) =  0.;
					}
					MtempP(kk) =tempp(iPath,m);
					Mcelltype(kk)=i;
					if(P_shape==Ellipsoid) 
					{
						MPT(kk) =0.56667e-6;  
			
					}
			    	else if(P_shape==RBC)  
					{
						MPT(kk) =2.*0.56667e-6;
				
					}
					else          
					{
						MPT(kk) = 2.*Rpvar1(i);
				
					}
		    		newiPath=kk-1;
					goto lab1;

				}

			}
		
			else if(Mtime0(kk) > tend)
			{
				newiPath=kk-1;
				goto lab1;
			}
	
		}
		
	}

lab1:

	if(flag==0) goto lab4;
	
	if(newiPath==0)  goto lab2;
    endk= (int)((tend-tstart)/Mts) + 1;
  //  for(dd=0; dd<=(nT-1); dd++)
	for(dd=0; dd<=(1-1); dd++)
	{
		if(dd%100==0) out(f,"\n  Summing Period %d !!",dd+1);
		for(j=1; j<=newiPath; j++ )
		{
			Mtime(j)=Mtime0(j) + dd*T;
		}

        kk = (int)(RoundOff((Mtime(1)-tstart)/Mts));

	    
	    for(j=kk0;j<=newiPath; j++)
	    {
			if(j+kk <= endk)
			{
			Mcount(kk+j) = Mcount(kk+j) + 1;

    		tZoneX(kk+j, Mcount(kk+j) )=MxP(j);
		    tZoneY(kk+j, Mcount(kk+j) )=MyP(j);
    		tZoneZ(kk+j, Mcount(kk+j) )=MzP(j);

	    	tZoneU(kk+j, Mcount(kk+j) )=MuP(j);
	    	tZoneV(kk+j, Mcount(kk+j) )=MvP(j);
	    	tZoneW(kk+j, Mcount(kk+j) )=MwP(j);
			
			tZoneOx(kk+j, Mcount(kk+j) )=MoxP(j);
			tZoneOy(kk+j, Mcount(kk+j) )=MoyP(j);
			tZoneOz(kk+j, Mcount(kk+j) )=MozP(j);
			tZoneEps1(kk+j, Mcount(kk+j) )=Meps1P(j);
			tZoneEps2(kk+j, Mcount(kk+j) )=Meps2P(j);
			tZoneEps3(kk+j, Mcount(kk+j) )=Meps3P(j);
			tZoneEta(kk+j, Mcount(kk+j) )=MetaP(j);
			


			tZoneTemp(kk+j, Mcount(kk+j) )=MtempP(j);
			tZoneCelltype(kk+j, Mcount(kk+j) )=Mcelltype(j);

			tZoneRP(kk+j, Mcount(kk+j) )=MPT(j);

			}
			else   break;
		}
	}
lab2:
	delete [] Mxyz_;
    delete [] Muvw_;
	
	delete MomegaX_;
    delete MomegaY_;
    delete MomegaZ_;
    delete Meps1P_;
    delete Meps2P_;
    delete Meps3P_;
    delete MetaP_;
	
    delete McellType_;
    delete Mtime_;
	delete Mtime0_;

}
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
void ReadTrack2_BIN(double t, double tstart,double tend, int i, int m, double Mts)
/**************************************************************************/
{

	int j,j1,  n, kk,nT, dd,js, flag;
	int cc, k,  endk, newiPath;
	
	
	double   tau;

	struct zigzag inZig;
    struct zigzag *ptr;

  /* the memory address we will send to readbinary */
    
	 ptr = &inZig;


	k=(int)(RoundOff(t/TimeStep));
	n=(int)(RoundOff(T/TimeStep));
	
	nT=(int)(RoundOff(tend/T));

    P_shape=celltype(i);
	
//	t2=(double)((k%n)*TimeStep);
	

/*	sprintf(jobtemp,"time_%lf_particle_%d.trkb", t2,i);
	ifrbdev(jobtemp) { out(f,"\n *ERROR-UNABLE TO OPEN %s", jobtemp); goto lab2; }
    else  
	{

		if(i%1==0) out(f,"\n time: %lf LOADING PROBLEM  DATA FROM FILE %s\n", t,jobtemp);
	}        */
	
    flag=0;
	js=1;

lab4:
	for(j1=js; ;j1++ )
	{
        if(j1%MaxIter==0) j=MaxIter;
		else              j=j1%MaxIter;
		
//      fscanf(rbdev,recform2,&time0(j),&TStep(j),&LoPa(j),&xP(j),&yP(j),&zP(j),&uP(j),&vP(j),&wP(j),&Act(j),&Weight(j));
		readBinary(rbdev,ptr);
        
		if(P_shape==Ellipsoid || P_shape==RBC)
		{
	
		LoPa(j,m) =inZig.a;
		time0(j) = inZig.b[0];                        
		TStep(j) = inZig.b[1];                        
		xP(j,m) = inZig.b[2];     
	    yP(j,m) = inZig.b[3];     
	    zP(j,m) = inZig.b[4];                      
        uP(j,m) = inZig.b[5];                    
        vP(j,m) = inZig.b[6];                       
        wP(j,m) = inZig.b[7];    
		oX(j,m) = inZig.b[8];
		oY(j,m) = inZig.b[9];
		oZ(j,m) = inZig.b[10];
		eps1_TR(j,m) = inZig.b[11];
		eps2_TR(j,m) = inZig.b[12];
		eps3_TR(j,m) = inZig.b[13];
		eta_TR(j,m) = inZig.b[14];
		tempp(j,m) = inZig.b[15];
		tempF(j,m) = inZig.b[16];
		alpha_chp(j,m)=inZig.b[17];
		Slope(j,m)=inZig.b[18];
   
		}
		else
		{
		LoPa(j,m) =inZig.a;
		time0(j) = inZig.b[0];                        
		TStep(j) = inZig.b[1];                        
		xP(j,m) = inZig.b[2];     
	    yP(j,m) = inZig.b[3];     
	    zP(j,m) = inZig.b[4];                      
        uP(j,m) = inZig.b[5];                    
        vP(j,m) = inZig.b[6];                       
        wP(j,m) = inZig.b[7];    
		tempp(j,m) = inZig.b[8];
		tempp(j,m) = inZig.b[9];
        alpha_chp(j,m) = inZig.b[10];     
        Weight(j) = inZig.b[11]; 
		Slope(j,m)=inZig.b[12];
		}

		if(TStep(j)<-10000000000.)  
		{
			printf(" timestep warning  \n");
		}

		if(j1%MaxIter==0)  
		{
			iPath=j;
			if(feof(rdev))  
		    {
				flag=1;
			    break;
			}
			else
			{
			    js=j1+1;
			    goto lab3;
			}
		}

		if(feof(rbdev))  
		{
			iPath=j;
			break;
		}
	}
	fclose(rbdev);

lab3:
	cc=1;
	newiPath=0;
	for(kk=1;  ; kk++)              // 다시 시간 단위로 재 배열
	{
		Mtime0(kk) = tstart + Mts*(kk-1);
		for(j=cc; j<=iPath-1; j++)
		{
			if((Mtime0(kk)  >= time0(j)) && (Mtime0(kk)  < time0(j+1))  )    
			{
                cc=j;  
				tau= (Mtime0(kk) - time0(j))/(time0(j+1) - time0(j));
				MxP(kk) = tau*xP(j+1,m) + (1.-tau)*xP(j,m);
				MyP(kk) = tau*yP(j+1,m) + (1.-tau)*yP(j,m);
				MzP(kk) = tau*zP(j+1,m) + (1.-tau)*zP(j,m);
				
				if(MzP(kk)>=10000) 
				{
					printf(" error \n");
				}
				MuP(kk) = tau*uP(j+1,m) + (1.-tau)*uP(j,m);
				MvP(kk) = tau*vP(j+1,m) + (1.-tau)*vP(j,m);
				MwP(kk) = tau*wP(j+1,m) + (1.-tau)*wP(j,m);
				if(P_shape==Ellipsoid || P_shape==RBC)
				{
					MoxP(kk) = tau*oX(j+1,m) + (1.-tau)*oX(j,m);
					MoyP(kk) = tau*oY(j+1,m) + (1.-tau)*oY(j,m);
					MozP(kk) = tau*oZ(j+1,m) + (1.-tau)*oZ(j,m);

					Meps1P(kk) = tau*eps1_TR(j+1,m) + (1.-tau)*eps1_TR(j,m);
					Meps2P(kk) = tau*eps2_TR(j+1,m) + (1.-tau)*eps2_TR(j,m);
					Meps3P(kk) = tau*eps3_TR(j+1,m) + (1.-tau)*eps3_TR(j,m);
					MetaP(kk) =  tau*eta_TR(j+1,m)  + (1.-tau)*eta_TR(j,m);

				}
				else
				{
					MoxP(kk) = 0.;
					MoyP(kk) = 0.;
					MozP(kk) = 0.;

					Meps1P(kk) = 0.;
					Meps2P(kk) = 0.;
					Meps3P(kk) = 0.;
					MetaP(kk) =  0.;
				}
				MtempP(kk) = tau*tempp(j+1,m) + (1.-tau)*tempp(j,m);
				Mcelltype(kk)=i;
				if(P_shape==Ellipsoid) 
				{
					MPT(kk) =0.56667e-6;  
	
				}
				else if(P_shape==RBC) 
				{
					MPT(kk) =2.*0.56667e-6;
				}
				else          
				{
					MPT(kk) = 2.*Rpvar1(i);
				}
				newiPath=kk;
				if(j==iPath-1 && Mtime0(kk)  < time0(iPath) )   goto lab1;
				else     break;
				
			}
			else if(Mtime0(kk)  >= time0(iPath) && Mtime0(kk)  <= tend)
			{
				if(TStep(iPath) > 100*T)
				{
					cc=iPath-1;  
				    MxP(kk) = xP(iPath,m) ;
				    MyP(kk) = yP(iPath,m) ;
				    MzP(kk) = zP(iPath,m) ;
					
				    if(MzP(kk)>=10000) 
				    {
						printf(" error \n");
				    }
			    	MuP(kk) = uP(iPath,m);
			    	MvP(kk) = vP(iPath,m);
			    	MwP(kk) = wP(iPath,m);
					if(P_shape==Ellipsoid || P_shape==RBC)
			     	{
					   MoxP(kk) = oX(iPath,m);
					   MoyP(kk) = oY(iPath,m);
					   MozP(kk) = oZ(iPath,m);

					   Meps1P(kk) = eps1_TR(iPath,m);
					   Meps2P(kk) = eps2_TR(iPath,m);
					   Meps3P(kk) = eps3_TR(iPath,m);
					   MetaP(kk) =  eta_TR(iPath,m);
				    }
					else
			    	{
					MoxP(kk) = 0.;
					MoyP(kk) = 0.;
					MozP(kk) = 0.;

					Meps1P(kk) = 0.;
					Meps2P(kk) = 0.;
					Meps3P(kk) = 0.;
					MetaP(kk) =  0.;
				    }
					MtempP(kk) = tempp(iPath,m);
//		     		MPT(kk) = Ptype(i);
					Mcelltype(kk)=i;
					if(P_shape==Ellipsoid) 
					{
						MPT(kk) =0.56667e-6; 
					}
				    else if(P_shape==RBC)  
					{
						MPT(kk) =2.*0.56667e-6;
					}
					else          
					{
						MPT(kk) = 2.*Rpvar1(i);
					}
		    		newiPath=kk;
		    		break;
				}
			}
		
			else if(Mtime0(kk) > tend)
			{
				newiPath=kk;
				goto   lab1;
			}
			
		
		}
		
	}



lab1:
	if(flag==0) goto lab4;
	if(newiPath==0)  goto lab2;
    endk= (int)(RoundOff((tend-tstart)/Mts)) + 1;
    for(dd=0; dd<=(1-1); dd++)
	{
		if(dd%100==0) out(f,"\n  Summing Period %d !!",dd+1);
		for(j=1; j<=newiPath; j++ )
		{
			Mtime(j)=Mtime0(j) + dd*T;
		}

        kk = (int)(RoundOff((Mtime(1)-tstart)/Mts));

	    
	    for(j=1;j<=newiPath; j++)
	    {
			if(j+kk <= endk)
			{
			Mcount(kk+j) = Mcount(kk+j) + 1;

    		tZoneX(kk+j, Mcount(kk+j) )=MxP(j);
		    tZoneY(kk+j, Mcount(kk+j) )=MyP(j);
    		tZoneZ(kk+j, Mcount(kk+j) )=MzP(j);

	    	tZoneU(kk+j, Mcount(kk+j) )=MuP(j);
	    	tZoneV(kk+j, Mcount(kk+j) )=MvP(j);
	    	tZoneW(kk+j, Mcount(kk+j) )=MwP(j);
			
			tZoneOx(kk+j, Mcount(kk+j) )=MoxP(j);
			tZoneOy(kk+j, Mcount(kk+j) )=MoyP(j);
			tZoneOz(kk+j, Mcount(kk+j) )=MozP(j);
			tZoneEps1(kk+j, Mcount(kk+j) )=Meps1P(j);
			tZoneEps2(kk+j, Mcount(kk+j) )=Meps2P(j);
			tZoneEps3(kk+j, Mcount(kk+j) )=Meps3P(j);
			tZoneEta(kk+j, Mcount(kk+j) )=MetaP(j);
			
		
			tZoneTemp(kk+j, Mcount(kk+j) )=MtempP(j);
			tZoneCelltype(kk+j, Mcount(kk+j) )=Mcelltype(j);

			tZoneRP(kk+j, Mcount(kk+j) )=MPT(j);
			}
			else   break;
		}
	}
lab2:
	;



}
/**************************************************************************/
int ImposeInletVel(int i,double t, int Lo)
/**************************************************************************/
{
	int    flag,m;
	double  del;
	flag=0;



	for(m=0; m<Nb; m++)
	{
        if(Mesh==Tetra)    Lo=InewTetra(&xP(1,m),Lo);
        else            Lo=Inew4(&xP(1,m),Lo);

	    if(Lo>0)
	    {
			if(WallCell2(Lo) == 3 || Nwall(Lo)!=0 || Nwall2(Lo)!=0 || Nwall3(Lo)!=0 || Nwall4(Lo)!=0 || Nwall5(Lo)!=0 || Nwall6(Lo)!=0 || Nwall7(Lo)!=0 )
		    {
			    del = Nwallb(Lo, &xP(1,m));
		        num_bound = Rpvar1(i);
		        if( (del <=num_bound) )  goto lab1;
		    }
			
		    flag=1;
		    if(STEADY==1)   
		    {
			    SteadyInter0(Lo, t, &xP(1,m), InVel_,InT_);
			    if(Magnet)   SteadyInter0(Lo, t, &xP(1,m), InVel_,Fm1_);
		    }

    	    else           
		    {
			    if(TempInt==0)   CubicInter1(Lo, t, &xP(1,m), InVel_, Fm1_);
			    else             LinearInter0(Lo, t, &xP(1,m), InVel_, Fm1_);
		    }
			uP(1,m)= InVel_[0];  
			vP(1,m)= InVel_[1];
			wP(1,m)= InVel_[2];
			tempp(1,m)=InT_[0];
			tempF(1,m)=InT_[0];
			if(heat)  
			{		
				alpha_chp(1,m)=1.;
			}
	    }
	}
lab1:

	Lo_init=Lo;
	
	return flag;

   	    

}
/**************************************************************************/
double uniform01(void)
/**************************************************************************/
{
    return rand()/((double) RAND_MAX + 1);
}

/**************************************************************************/
/**************************************************************************/
void Make_Elliptic_Init(int is)
/**************************************************************************/
{

	if(P_shape==Ellipsoid)   
	{
		Minor_a=Rpvar1(is);
		Major_b=Rpvar2(is);
		Beta_ab=Major_b/Minor_a;
		Vo = 4.*PI*Minor_a*Minor_a*Minor_a*Beta_ab/3.;
		
	}
	else if(P_shape==RBC) 
	{
		Minor_a=3.4625e-6;
		Major_b=1.33086e-6;
		Beta_ab=Major_b/Minor_a;
		Vo = 98.e-18;	
	}
	
	Mp = rhop*Vo;
	beta_ab2=Beta_ab*Beta_ab;
	Ip[0]=0.2*(1.+beta_ab2)* Minor_a*Minor_a*Mp;
	Ip[1]=0.4* Minor_a*Minor_a*Mp;
	Ip[2]=0.2*(1.+beta_ab2)* Minor_a*Minor_a*Mp;
	


	if(Beta_ab>1.)
	{
		sq_beta_ab2minusOne=sqrt(fabs(beta_ab2-1.));
		log_beta_ab2=log(Beta_ab + sq_beta_ab2minusOne);
		Kxx=16.*pow(sq_beta_ab2minusOne,3)/( (2.*sq_beta_ab2minusOne*sq_beta_ab2minusOne - 1.)*log_beta_ab2 + Beta_ab*sq_beta_ab2minusOne);
	    Kzz=Kxx;
	    Kyy=8.*pow(sq_beta_ab2minusOne,3)/( (2.*sq_beta_ab2minusOne*sq_beta_ab2minusOne + 1.)*log_beta_ab2 - Beta_ab*sq_beta_ab2minusOne);
	    Minor_a2=Minor_a*Minor_a;
	    Major_b2=Major_b*Major_b;

	    Minor_a3=Minor_a2*Minor_a;

	    betaMinusaOne=beta_ab2-1.;
	
	    Beta_ab0 = -2./betaMinusaOne - Beta_ab*(pow(betaMinusaOne,-3./2.))*log((Beta_ab - sq_beta_ab2minusOne)/(Beta_ab + sq_beta_ab2minusOne));
	    Alpha_ab0= beta_ab2/betaMinusaOne + 0.5*Beta_ab*(pow(betaMinusaOne,-3./2.))*log((Beta_ab - sq_beta_ab2minusOne)/(Beta_ab + sq_beta_ab2minusOne));
        Gamma_ab0= Alpha_ab0;
	}
	else if(Beta_ab==1.0)
	{
		Kxx=6.;Kyy=6.;Kzz=6.;
		Minor_a2=Minor_a*Minor_a;
	    Major_b2=Major_b*Major_b;
		Minor_a3=Minor_a2*Minor_a;
		Alpha_ab0=2./3.;
		Beta_ab0 =Alpha_ab0;
		Gamma_ab0=Alpha_ab0;
	}
	else if(Beta_ab<1.)
	{
		sq_beta_ab2minusOne=sqrt(fabs(beta_ab2-1.));
	    log_beta_ab2=atan(sq_beta_ab2minusOne/Beta_ab);
		Kxx=16.*pow(sq_beta_ab2minusOne,3)/( (2.*sq_beta_ab2minusOne*sq_beta_ab2minusOne - 1.)*log_beta_ab2 - Beta_ab*sq_beta_ab2minusOne);
	    Kzz=Kxx;
	    Kyy=8.*pow(sq_beta_ab2minusOne,3)/( (2.*sq_beta_ab2minusOne*sq_beta_ab2minusOne - 1.)*log_beta_ab2 + Beta_ab*sq_beta_ab2minusOne);
		Minor_a2=Minor_a*Minor_a;
	    Major_b2=Major_b*Major_b;

	    Minor_a3=Minor_a2*Minor_a;

	    betaMinusaOne=1.-beta_ab2;
	
	    Beta_ab0 = 2./betaMinusaOne - 2.*Beta_ab*(pow(betaMinusaOne,-3./2.))*atan(sqrt(betaMinusaOne)/Beta_ab);
	    Alpha_ab0= beta_ab2/betaMinusaOne + Beta_ab*(pow(betaMinusaOne,-3./2.))*atan(sqrt(betaMinusaOne)/Beta_ab);
        Gamma_ab0= Alpha_ab0;
	}
}

void Transform_A(double omega1[],double epsV[], double DVfDx[], double DVfDy[], double DVfDz[], 
				 double DDVf_xx[],double DDVf_yy[],double DDVf_zz[], double DDVf_xy[],double DDVf_xz[],double DDVf_yz[])
/**************************************************************************/
{
	double T_DDVf[3];

	int i,j;

	Tran_A(0,0)=1.-2.*(epsV[1]*epsV[1]+epsV[2]*epsV[2]);
	Tran_A(0,1)=2.*(epsV[0]*epsV[1]+epsV[2]*epsV[3]);
	Tran_A(0,2)=2.*(epsV[0]*epsV[2]-epsV[1]*epsV[3]);
	Tran_A(1,0)=2.*(epsV[0]*epsV[1]-epsV[2]*epsV[3]);
	Tran_A(1,1)=1.-2.*(epsV[0]*epsV[0]+epsV[2]*epsV[2]);
	Tran_A(1,2)=2.*(epsV[1]*epsV[2]+epsV[0]*epsV[3]);
	Tran_A(2,0)=2.*(epsV[0]*epsV[2]+epsV[1]*epsV[3]);
	Tran_A(2,1)=2.*(epsV[1]*epsV[2]-epsV[0]*epsV[3]);
	Tran_A(2,2)=1.-2.*(epsV[0]*epsV[0]+epsV[1]*epsV[1]);

	for(i=0;i<3;i++)
		for(j=0;j<3;j++)   ITran_A(j,i)=Tran_A(i,j);

	KMat(1,1)=pow(Tran_A(0,0),2.)*Kxx + pow(Tran_A(1,0),2.)*Kyy + pow(Tran_A(2,0),2.)*Kzz;
    KMat(1,2)=Tran_A(0,0)*Tran_A(0,1)*Kxx + Tran_A(1,0)*Tran_A(1,1)*Kyy + Tran_A(2,0)*Tran_A(2,1)*Kzz;
	KMat(1,3)=Tran_A(0,0)*Tran_A(0,2)*Kxx + Tran_A(1,0)*Tran_A(1,2)*Kyy + Tran_A(2,0)*Tran_A(2,2)*Kzz;

	KMat(2,1)=KMat(1,2);
	KMat(2,2)=pow(Tran_A(0,1),2.)*Kxx + pow(Tran_A(1,1),2.)*Kyy + pow(Tran_A(2,1),2.)*Kzz;
    KMat(2,3)=Tran_A(0,1)*Tran_A(0,2)*Kxx + Tran_A(1,1)*Tran_A(1,2)*Kyy + Tran_A(2,1)*Tran_A(2,2)*Kzz;

	KMat(3,1)=KMat(1,3);
    KMat(3,1)=KMat(2,3);
	KMat(3,3)=pow(Tran_A(0,2),2.)*Kxx + pow(Tran_A(1,2),2.)*Kyy + pow(Tran_A(2,2),2.)*Kzz;

	dKMat_e1(1,1)= 8.*epsV[1]*(epsV[0]*epsV[1] - epsV[2]*epsV[3])*Kyy + 8.*epsV[2]*(epsV[0]*epsV[2] + epsV[1]*epsV[3])*Kzz;
	dKMat_e2(1,1)= 8.*(epsV[1]*(-1. + 2.*pow(epsV[1],2.) + 2.*pow(epsV[2],2.))*Kxx + epsV[0]*(epsV[0]*epsV[1] - epsV[2]*epsV[3])*Kyy + 
     epsV[3]*(epsV[0]*epsV[2] + epsV[1]*epsV[3])*Kzz);
	dKMat_e3(1,1)= 8.*(epsV[2]*(-1. + 2.*pow(epsV[1],2.) + 2.*pow(epsV[2],2.))*Kxx + epsV[3]*(-(epsV[0]*epsV[1]) + epsV[2]*epsV[3])*Kyy + 
     epsV[0]*(epsV[0]*epsV[2] + epsV[1]*epsV[3])*Kzz);
	dKMat_e4(1,1)= 8.*epsV[2]*(-(epsV[0]*epsV[1]) + epsV[2]*epsV[3])*Kyy + 8.*epsV[1]*(epsV[0]*epsV[2] + epsV[1]*epsV[3])*Kzz;

	dKMat_e1(1,2)= -4.*pow(epsV[1],3.)*(Kxx - 3.*Kyy) + 8.*epsV[0]*epsV[2]*epsV[3]*(Kyy - Kzz) + 
   epsV[1]*(2.*Kxx - 10.*Kyy + pow(epsV[3],2.)*(12.*Kyy - 4.*Kzz) + pow(epsV[2],2.)*(-4.*Kxx + 8.*Kyy + 4.*Kzz));
	dKMat_e2(1,2)= 8.*epsV[1]*epsV[2]*epsV[3]*(-Kxx + Kzz) + epsV[0]*(2.*Kxx - 2.*Kyy + 4.*pow(epsV[1],2.)*(-3.*Kxx + Kyy) + 4.*pow(epsV[3],2.)*(Kyy - Kzz) + 
      pow(epsV[2],2.)*(-4.*Kxx + 4.*Kzz));
	dKMat_e3(1,2)= 2.*epsV[3]*(Kxx + Kyy - 2.*Kzz) - 4.*pow(epsV[1],2.)*epsV[3]*(Kxx + Kyy - 2.*Kzz) - 8.*epsV[0]*epsV[1]*epsV[2]*(Kxx + Kyy - Kzz) + 
   4.*pow(epsV[2],2.)*epsV[3]*(-3.*Kxx + 2.*Kyy + Kzz) + pow(epsV[3],3.)*(-4.*Kyy + 4.*Kzz);
	dKMat_e4(1,2)= 2.*epsV[2]*(Kxx + Kyy - 2.*Kzz) - 4.*pow(epsV[1],2.)*epsV[2]*(Kxx + Kyy - 2.*Kzz) - 8.*epsV[0]*epsV[1]*epsV[3]*Kzz + 
   pow(epsV[2],3.)*(-4.*Kxx + 4.*Kzz) + epsV[2]*pow(epsV[3],2.)*(-4.*Kyy + 4.*Kzz);

	dKMat_e1(1,3)= -4.*pow(epsV[2],3.)*(Kxx - 3.*Kzz) + 8.*epsV[0]*epsV[1]*epsV[3]*(Kyy - Kzz) + 
   epsV[2]*(2.*Kxx - 4.*pow(epsV[3],2.)*(Kyy - 3.*Kzz) - 10.*Kzz + pow(epsV[1],2.)*(-4.*Kxx + 4.*Kyy + 8.*Kzz));
	dKMat_e2(1,3)= -2.*epsV[3]*(Kxx - 2.*Kyy + Kzz) + 4.*pow(epsV[2],2.)*epsV[3]*(Kxx - 2.*Kyy + Kzz) - 8.*epsV[0]*epsV[1]*epsV[2]*(Kxx - Kyy + Kzz) + 
   pow(epsV[3],3.)*(-4.*Kyy + 4.*Kzz) + pow(epsV[1],2.)*epsV[3]*(12.*Kxx - 4.*(Kyy + 2.*Kzz));
	dKMat_e3(1,3)= 8.*epsV[1]*epsV[2]*epsV[3]*(Kxx - Kyy) + epsV[0]*(2.*Kxx + pow(epsV[1],2.)*(-4.*Kxx + 4.*Kyy) - 2.*Kzz + 
      4*pow(epsV[2],2.)*(-3.*Kxx + Kzz) + pow(epsV[3],2.)*(-4.*Kyy + 4.*Kzz));
	dKMat_e4(1,3)= 4.*pow(epsV[1],3.)*(Kxx - Kyy) - 8.*epsV[0]*epsV[2]*epsV[3]*Kyy - 2.*epsV[1]*(Kxx - 2.*Kyy + Kzz) + 
   4.*epsV[1]*pow(epsV[2],2.)*(Kxx - 2.*Kyy + Kzz) + epsV[1]*pow(epsV[3],2.)*(-4.*Kyy + 4.*Kzz);

	dKMat_e1(2,1)= pow(epsV[1],3.)*(-4.*Kxx + 4.*Kyy) - 8.*epsV[0]*epsV[2]*epsV[3]*Kzz + 
   epsV[1]*(2.*Kxx - 2.*Kyy + 4.*pow(epsV[3],2.)*(Kyy - Kzz) + pow(epsV[2],2.)*(-4.*Kxx + 4.*Kzz));
	dKMat_e2(2,1)= -8.*epsV[1]*epsV[2]*epsV[3]*(Kxx + Kyy - Kzz) + epsV[0]*(2.*Kxx - 12.*pow(epsV[1],2.)*(Kxx - Kyy) - 2.*Kyy + 
      4.*pow(epsV[3],2.)*(Kyy - Kzz) + pow(epsV[2],2.)*(-4.*Kxx + 4.*Kzz));
	dKMat_e3(2,1)= 2.*epsV[3]*(Kxx + Kyy - 2.*Kzz) - 4.*pow(epsV[1],2.)*epsV[3]*(Kxx + Kyy - 2.*Kzz) + 4.*pow(epsV[2],2.)*epsV[3]*(-3.*Kxx + Kzz) + 
   pow(epsV[3],3.)*(-4.*Kyy + 4.*Kzz) + epsV[0]*epsV[1]*epsV[2]*(-8.*Kxx + 8.*Kzz);
	dKMat_e4(2,1)= 8.*epsV[0]*epsV[1]*epsV[3]*(Kyy - Kzz) + pow(epsV[2],3.)*(-4.*Kxx + 4.*Kzz) + 
   2.*epsV[2]*(Kxx + Kyy - 2.*pow(epsV[1],2.)*(Kxx + Kyy - 2.*Kzz) - 2.*Kzz + 2.*pow(epsV[3],2.)*(-3.*Kyy + Kzz));


	dKMat_e1(2,2)= 8.*(epsV[0]*pow(epsV[1],2.)*Kxx + epsV[1]*epsV[2]*epsV[3]*(Kxx - Kzz) + epsV[0]*pow(epsV[3],2.)*Kzz);
	dKMat_e2(2,2)= 8.*(epsV[0]*(epsV[0]*epsV[1] + epsV[2]*epsV[3])*Kxx + epsV[1]*(-1. + 2.*pow(epsV[1],2.) + 2.*pow(epsV[3],2.))*Kyy + 
     epsV[2]*(epsV[1]*epsV[2] - epsV[0]*epsV[3])*Kzz);
	dKMat_e3(2,2)= 8.*(epsV[2]*pow(epsV[3],2.)*Kxx + epsV[0]*epsV[1]*epsV[3]*(Kxx - Kzz) + pow(epsV[1],2.)*epsV[2]*Kzz);
	dKMat_e4(2,2)= 8.*(epsV[2]*(epsV[0]*epsV[1] + epsV[2]*epsV[3])*Kxx + epsV[3]*(-1. + 2.*pow(epsV[1],2.) + 2.*pow(epsV[3],2.))*Kyy + 
     epsV[0]*(-(epsV[1]*epsV[2]) + epsV[0]*epsV[3])*Kzz);

	dKMat_e1(2,3)= 8.*epsV[0]*epsV[1]*epsV[2]*(Kxx - Kzz) + epsV[3]*(-2.*Kyy + 4.*pow(epsV[2],2.)*(Kxx - 3.*Kzz) + 4.*pow(epsV[3],2.)*(Kyy - 3.*Kzz) + 
      10.*Kzz - 4.*pow(epsV[1],2.)*(Kxx - Kyy + 2.*Kzz));
	dKMat_e2(2,3)= 8.*epsV[0]*epsV[1]*epsV[3]*(-Kxx + Kyy + Kzz) + pow(epsV[2],3.)*(-4.*Kxx + 4.*Kzz) + 
   epsV[2]*(4.*Kxx - 2.*Kyy - 2.*Kzz + 4.*pow(epsV[3],2.)*(-2.*Kxx + Kyy + Kzz) - 4.*pow(epsV[1],2.)*(Kxx - 3.*Kyy + 2.*Kzz));
	dKMat_e3(2,3)= 8.*epsV[0]*epsV[2]*epsV[3]*Kxx + epsV[1]*(pow(epsV[3],2.)*(-4.*Kxx + 4.*Kyy) + 2.*(-1 + 2.*pow(epsV[1],2.))*(Kyy - Kzz)) + 
   4.*pow(epsV[0],2.)*epsV[1]*(Kxx - Kzz);
	dKMat_e4(2,3)= 8.*epsV[1]*epsV[2]*epsV[3]*(-Kxx + Kyy) + epsV[0]*(-2.*Kyy + pow(epsV[1],2.)*(-4.*Kxx + 4.*Kyy) + pow(epsV[3],2.)*(12.*Kyy - 4.*Kzz) + 
      4*pow(epsV[2],2.)*(Kxx - Kzz) + 2.*Kzz);

	dKMat_e1(3,1)= 8.*epsV[0]*epsV[1]*epsV[3]*Kyy + pow(epsV[2],3.)*(-4.*Kxx + 4.*Kzz) + 
   epsV[2]*(2.*Kxx + pow(epsV[1],2.)*(-4.*Kxx + 4.*Kyy) - 2.*Kzz + pow(epsV[3],2.)*(-4.*Kyy + 4.*Kzz));
	dKMat_e2(3,1)= pow(epsV[1],2.)*epsV[3]*(12.*Kxx - 4.*Kyy) + epsV[0]*epsV[1]*epsV[2]*(-8.*Kxx + 8.*Kyy) - 2.*epsV[3]*(Kxx - 2.*Kyy + Kzz) + 
   4.*pow(epsV[2],2.)*epsV[3]*(Kxx - 2.*Kyy + Kzz) + pow(epsV[3],3.)*(-4.*Kyy + 4.*Kzz);
	dKMat_e3(3,1)= 8.*epsV[1]*epsV[2]*epsV[3]*(Kxx - Kyy + Kzz) + epsV[0]*(2.*Kxx + pow(epsV[1],2.)*(-4.*Kxx + 4.*Kyy) - 12.*pow(epsV[2],2.)*(Kxx - Kzz) - 
      2.*Kzz + pow(epsV[3],2.)*(-4.*Kyy + 4.*Kzz));
	dKMat_e4(3,1)= 4.*pow(epsV[1],3.)*(Kxx - Kyy) + 8.*epsV[0]*epsV[2]*epsV[3]*(-Kyy + Kzz) + 
   epsV[1]*(-2.*Kxx + 4.*Kyy - 4.*pow(epsV[3],2.)*(Kyy - 3.*Kzz) - 2.*Kzz + 4.*pow(epsV[2],2.)*(Kxx - 2.*Kyy + Kzz));

	dKMat_e1(3,2)= 8.*epsV[0]*epsV[1]*epsV[2]*(Kxx - Kyy) + epsV[3]*(-4.*pow(epsV[1],2.)*(Kxx - 3.*Kyy) - 10.*Kyy + pow(epsV[3],2.)*(12.*Kyy - 4.*Kzz) + 
      4.*pow(epsV[2],2.)*(Kxx + 2.*Kyy - Kzz) + 2.*Kzz);
	dKMat_e2(3,2)= 2.*(-4.*epsV[0]*epsV[1]*epsV[3]*Kxx + 2.*pow(epsV[0],2.)*epsV[2]*(Kxx - Kyy) + 
     epsV[2]*(-((-1. + 2.*pow(epsV[2],2.))*(Kyy - Kzz)) + pow(epsV[3],2.)*(-2.*Kxx + 2.*Kzz)));
	dKMat_e3(3,2)= pow(epsV[1],3.)*(-4.*Kxx + 4.*Kyy) + 8.*epsV[0]*epsV[2]*epsV[3]*(Kxx - Kyy - Kzz) + 
   epsV[1]*(4.*Kxx - 2.*Kyy - 4.*pow(epsV[2],2.)*(Kxx + 2.*Kyy - 3.*Kzz) - 2.*Kzz + 4.*pow(epsV[3],2.)*(-2.*Kxx + Kyy + Kzz));
	dKMat_e4(3,2)= 8.*epsV[1]*epsV[2]*epsV[3]*(-Kxx + Kzz) + epsV[0]*(-2.*Kyy + pow(epsV[1],2.)*(-4.*Kxx + 4.*Kyy) + 4.*pow(epsV[3],2.)*(Kyy - 3*Kzz) + 
      4.*pow(epsV[2],2.)*(Kxx - Kzz) + 2.*Kzz);

	dKMat_e1(3,3)= 8.*epsV[2]*(epsV[0]*epsV[2] - epsV[1]*epsV[3])*Kxx + 8.*epsV[3]*(epsV[1]*epsV[2] + epsV[0]*epsV[3])*Kyy;
	dKMat_e2(3,3)= 8.*epsV[3]*(-(epsV[0]*epsV[2]) + epsV[1]*epsV[3])*Kxx + 8.*epsV[2]*(epsV[1]*epsV[2] + epsV[0]*epsV[3])*Kyy;
	dKMat_e3(3,3)= 8.*(epsV[0]*(epsV[0]*epsV[2] - epsV[1]*epsV[3])*Kxx + epsV[1]*(epsV[1]*epsV[2] + epsV[0]*epsV[3])*Kyy + 
     epsV[2]*(-1. + 2.*pow(epsV[2],2.) + 2.*pow(epsV[3],2.))*Kzz);
	dKMat_e4(3,3)= 8.*(epsV[1]*(-(epsV[0]*epsV[2]) + epsV[1]*epsV[3])*Kxx + epsV[0]*(epsV[1]*epsV[2] + epsV[0]*epsV[3])*Kyy + 
     epsV[3]*(-1. + 2.*pow(epsV[2],2.) + 2.*pow(epsV[3],2.))*Kzz);



	for(i=0; i<3; i++)
	{
		Tran_DVfDx[i]=0.;
		Tran_DVfDy[i]=0.;
		Tran_DVfDz[i]=0.;
	}

    for(i=0; i<3; i++)
	{
		for(j=0; j<3; j++)
		{
			Tran_DVfDx[i]+=Tran_A(i,j)*DVfDx[j]*ITran_A(0,0) + Tran_A(i,j)*DVfDy[j]*ITran_A(1,0) + Tran_A(i,j)*DVfDz[j]*ITran_A(2,0);
			Tran_DVfDy[i]+=Tran_A(i,j)*DVfDx[j]*ITran_A(0,1) + Tran_A(i,j)*DVfDy[j]*ITran_A(1,1) + Tran_A(i,j)*DVfDz[j]*ITran_A(2,1);
			Tran_DVfDz[i]+=Tran_A(i,j)*DVfDx[j]*ITran_A(0,2) + Tran_A(i,j)*DVfDy[j]*ITran_A(1,2) + Tran_A(i,j)*DVfDz[j]*ITran_A(2,2);
		}
	}


//	MatVecProduct(Tran_DVfDx, Tran_A_, T_DVfDx, 3, 3);
//	MatVecProduct(Tran_DVfDy, Tran_A_, T_DVfDy, 3, 3);
//	MatVecProduct(Tran_DVfDz, Tran_A_, T_DVfDz, 3, 3);

	dzy=0.5*(Tran_DVfDy[2]+Tran_DVfDz[1]);
	dyx=0.5*(Tran_DVfDx[1]+Tran_DVfDy[0]);
	
	wzy=0.5*(Tran_DVfDy[2]-Tran_DVfDz[1]);
	wxz=0.5*(Tran_DVfDz[0]-Tran_DVfDx[2]);
    wyx=0.5*(Tran_DVfDx[1]-Tran_DVfDy[0]);

	dThdo_[0]=16.*PI*mu*Minor_a3*Beta_ab/(3.*(beta_ab2*Beta_ab0+Gamma_ab0))*(beta_ab2+1);
	dThdo_[1]=32.*PI*mu*Minor_a3*Beta_ab/(3.*(Gamma_ab0+Alpha_ab0));
	dThdo_[2]=16.*PI*mu*Minor_a3*Beta_ab/(3.*(beta_ab2*Beta_ab0+Alpha_ab0))*(beta_ab2+1);

	/*Th_[0]=16.*PI*mu*Minor_a3*Beta_ab/(3.*(beta_ab2*Beta_ab0+Gamma_ab0))*( (beta_ab2-1.)*dzy + (beta_ab2+1)*(wzy-omega1[0]));
	Th_[1]=32.*PI*mu*Minor_a3*Beta_ab/(3.*(Gamma_ab0+Alpha_ab0))*(wxz-omega1[1]+omega_fla);
	Th_[2]=16.*PI*mu*Minor_a3*Beta_ab/(3.*(beta_ab2*Beta_ab0+Alpha_ab0))*( (1.- beta_ab2)*dyx + (beta_ab2+1)*(wyx-omega1[2]));  */

	for(i=0; i<3; i++)
	{
		T_DDVf[i]= DDVf_xx[i]*(Minor_a2*ITran_A(0,0)*ITran_A(0,0) + Major_b2*ITran_A(0,1)*ITran_A(0,1) + Minor_a2*ITran_A(0,2)*ITran_A(0,2))
			     + DDVf_yy[i]*(Minor_a2*ITran_A(1,0)*ITran_A(1,0) + Major_b2*ITran_A(1,1)*ITran_A(1,1) + Minor_a2*ITran_A(1,2)*ITran_A(1,2))
			     + DDVf_zz[i]*(Minor_a2*ITran_A(2,0)*ITran_A(2,0) + Major_b2*ITran_A(2,1)*ITran_A(2,1) + Minor_a2*ITran_A(2,2)*ITran_A(2,2))
			  +2.* DDVf_xy[i]*(Minor_a2*ITran_A(0,0)*ITran_A(1,0) + Major_b2*ITran_A(0,1)*ITran_A(1,1) + Minor_a2*ITran_A(0,2)*ITran_A(1,2))
			  +2.* DDVf_xz[i]*(Minor_a2*ITran_A(0,0)*ITran_A(2,0) + Major_b2*ITran_A(0,1)*ITran_A(2,1) + Minor_a2*ITran_A(0,2)*ITran_A(2,2))
			  +2.* DDVf_yz[i]*(Minor_a2*ITran_A(1,0)*ITran_A(2,0) + Major_b2*ITran_A(1,1)*ITran_A(2,1) + Minor_a2*ITran_A(1,2)*ITran_A(2,2));
		
	//	Sec_Vis_F[i]=mu*Kvec[i]*T_DDVf[i]/6.;   /*  second term for viscous drag force  */
	}


}
/**************************************************************************/
void Find_Orientation(double output[])
/**************************************************************************/
{
	double y[3];

	y[0]=0.; y[1]=1.; y[2]=0.;
	MatVecProduct(output, ITran_A_, y, 3, 3);
	
}

/**************************************************************************/
void Direct_cosine()
/**************************************************************************/
{
	int i;
	double x[3],y[3],z[3];
	double x1[3],y1[3],z1[3];
	double aa11,aa12,aa13;
	double aa21,aa22,aa23;
	double aa31,aa32,aa33;
	
	

	for(i=0; i<3; i++)
	{
		x[i]=0.;
		x1[i]=0.;
		y[i]=0.;
		y1[i]=0.;
		z[i]=0.;
		z1[i]=0.;
	}
	x[0]=1.;   y[1]=1.;   z[2]=1.;
	x1[0]=-1.; y1[1]=-1.; z1[2]=1.;
	aa11=Dot(x,x1); 
	aa12=Dot(x,y1); 
	aa13=Dot(x,z1);
	aa21=Dot(y,x1); 
	aa22=Dot(y,y1); 
	aa23=Dot(y,z1);
	aa31=Dot(z,x1); 
	aa32=Dot(z,y1); 
	aa33=Dot(z,z1);

	eta=0.5*sqrt(1.+aa11+aa22+aa33);
	if(eta!=0)
	{
	eps1=0.25*(aa23-aa32)/(eta+smallest);
	eps2=0.25*(aa31-aa13)/(eta+smallest);
	eps3=0.25*(aa12-aa21)/(eta+smallest);
	}
	else
	{
		eps1=sqrt(0.5*(1.+ aa11));
		if(eps1 != 0)
		{
			eps2 = 0.5*aa12/eps1;
		}
		else
		{
			eps2=sqrt(0.5*(1.+ aa22));
		}
		if(eps2 != 0)
		{
			eps3 = 0.5*aa23/eps2;
		}
		else
		{
			eps3=sqrt(0.5*(1.+ aa33));
		}
	}
}

void Function_ellipsoid(int pn,double theta, double phi, double output[])
/**************************************************************************/
{
	double a,b;

	if(P_shape==Ellipsoid)
	{
		a=Rpvar1(pn);
	    b=Rpvar2(pn);

	    output[0]=a*sin(theta)*cos(phi);
	    output[1]=b*sin(phi);
	    output[2]=a*cos(theta)*cos(phi); 
	}
	else if(P_shape==RBC)
	{
		a=2.5e-6;
	    b=1.38581894;

	    output[0]=(a*b-0.56667e-6)*sin(phi)*cos(theta);
	    output[1]=(0.5*a*b-0.56667e-6)*(0.207+2.003*pow(sin(phi),2.) - 1.123*pow(sin(phi),4.))*cos(phi);
	    output[2]=(a*b-0.56667e-6)*sin(phi)*sin(theta);
	}
}
/**************************************************************************/
void Make_ellipsoid(int pn, double xyzPc[], double epsV[], int m, double y2[])
/**************************************************************************/
{
	int i,j,count;
	double theta,phi;
	double y1[3];
	typexyz output[266],output2[266];

	Tran_A(0,0)=1.-2.*(epsV[1]*epsV[1]+epsV[2]*epsV[2]);
	Tran_A(0,1)=2.*(epsV[0]*epsV[1]+epsV[2]*epsV[3]);
	Tran_A(0,2)=2.*(epsV[0]*epsV[2]-epsV[1]*epsV[3]);
	Tran_A(1,0)=2.*(epsV[0]*epsV[1]-epsV[2]*epsV[3]);
	Tran_A(1,1)=1.-2.*(epsV[0]*epsV[0]+epsV[2]*epsV[2]);
	Tran_A(1,2)=2.*(epsV[1]*epsV[2]+epsV[0]*epsV[3]);
	Tran_A(2,0)=2.*(epsV[0]*epsV[2]+epsV[1]*epsV[3]);
	Tran_A(2,1)=2.*(epsV[1]*epsV[2]-epsV[0]*epsV[3]);
	Tran_A(2,2)=1.-2.*(epsV[0]*epsV[0]+epsV[1]*epsV[1]);

	for(i=0;i<3;i++)
		for(j=0;j<3;j++)   ITran_A(j,i)=Tran_A(i,j);

	if(P_shape==Ellipsoid)
	{
	    theta=0.; phi=0.5*PI;
	    Function_ellipsoid(pn, theta, phi, &output[0].v1[0]);
	    count=0;

	    phi=-0.729728;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn,theta, phi, &output[count].v1[0]);
	    }
	    phi=-0.339837;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn,theta, phi, &output[count].v1[0]);
	    }
	    phi=0.;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn,theta, phi, &output[count].v1[0]);
	    }
	    phi=0.339837;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn,theta, phi, &output[count].v1[0]);
	    }
	    phi=0.729728;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn,theta, phi, &output[count].v1[0]);
	    }
	
	    theta=0.; phi=-0.5*PI;
	    Function_ellipsoid(pn, theta, phi, &output[31].v1[0]);
		for(i=0; i<32; i++)
	    {
		    MatVecProduct(&output2[i].v1[0], ITran_A_, &output[i].v1[0], 3, 3);
		    for(j=0; j<3; j++)
		    {
			    xyzP_EL(m,i+1,j+1) = output2[i].v1[j] + xyzPc[j];
		    }
	    }
	}
	y1[0]=0.; y1[1]=1.0; y1[2]=0.;
	MatVecProduct(&y2[0], ITran_A_, &y1[0], 3, 3);

}
/**************************************************************************/
void Make_ellipsoid_in_Deposition(int pn,double xyzPc[], double epsV[], int m)
/**************************************************************************/
{
	int i,j,count;
	double theta,phi;
//	double y1[3];
	typexyz output[266],output2[266];

	Tran_A(0,0)=1.-2.*(epsV[1]*epsV[1]+epsV[2]*epsV[2]);
	Tran_A(0,1)=2.*(epsV[0]*epsV[1]+epsV[2]*epsV[3]);
	Tran_A(0,2)=2.*(epsV[0]*epsV[2]-epsV[1]*epsV[3]);
	Tran_A(1,0)=2.*(epsV[0]*epsV[1]-epsV[2]*epsV[3]);
	Tran_A(1,1)=1.-2.*(epsV[0]*epsV[0]+epsV[2]*epsV[2]);
	Tran_A(1,2)=2.*(epsV[1]*epsV[2]+epsV[0]*epsV[3]);
	Tran_A(2,0)=2.*(epsV[0]*epsV[2]+epsV[1]*epsV[3]);
	Tran_A(2,1)=2.*(epsV[1]*epsV[2]-epsV[0]*epsV[3]);
	Tran_A(2,2)=1.-2.*(epsV[0]*epsV[0]+epsV[1]*epsV[1]);

	for(i=0;i<3;i++)
		for(j=0;j<3;j++)   ITran_A(j,i)=Tran_A(i,j);

	if(P_shape==Ellipsoid)
	{
	    theta=0.; phi=0.5*PI;
	    Function_ellipsoid(pn, theta, phi, &output[0].v1[0]);
	    count=0;

	    phi=-0.729728;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn, theta, phi, &output[count].v1[0]);
	    }
	    phi=-0.339837;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn, theta, phi, &output[count].v1[0]);
	    }
	    phi=0.;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn, theta, phi, &output[count].v1[0]);
	    }
	    phi=0.339837;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn, theta, phi, &output[count].v1[0]);
	    }
	    phi=0.729728;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn, theta, phi, &output[count].v1[0]);
	    }
	
	    theta=0.; phi=-0.5*PI;
	    Function_ellipsoid(pn, theta, phi, &output[31].v1[0]);
		for(i=0; i<32; i++)
	    {
		    MatVecProduct(&output2[i].v1[0], ITran_A_, &output[i].v1[0], 3, 3);
		    for(j=0; j<3; j++)
		    {
			    xyzP_EL_DP(m,i+1,j+1) = output2[i].v1[j] + xyzPc[j];
		    }
	    }
	}
}

/**************************************************************************/
void Make_ellipsoid_in_Solver(int pn, double xyzPc[],double epsV[], double y2[])
/**************************************************************************/
{
	int i,j,count;
	double theta,phi;
	double y1[3];
	typexyz output[266],output2[266];
	double temp[10];

	Tran_A(0,0)=1.-2.*(epsV[1]*epsV[1]+epsV[2]*epsV[2]);
	Tran_A(0,1)=2.*(epsV[0]*epsV[1]+epsV[2]*epsV[3]);
	Tran_A(0,2)=2.*(epsV[0]*epsV[2]-epsV[1]*epsV[3]);
	Tran_A(1,0)=2.*(epsV[0]*epsV[1]-epsV[2]*epsV[3]);
	Tran_A(1,1)=1.-2.*(epsV[0]*epsV[0]+epsV[2]*epsV[2]);
	Tran_A(1,2)=2.*(epsV[1]*epsV[2]+epsV[0]*epsV[3]);
	Tran_A(2,0)=2.*(epsV[0]*epsV[2]+epsV[1]*epsV[3]);
	Tran_A(2,1)=2.*(epsV[1]*epsV[2]-epsV[0]*epsV[3]);
	Tran_A(2,2)=1.-2.*(epsV[0]*epsV[0]+epsV[1]*epsV[1]);

	for(i=0;i<3;i++)
	{
		for(j=0;j<3;j++)   
		{
			ITran_A(j,i)=Tran_A(i,j);
			In_Ibody(i,j)=0.;
		}
	}
	In_Ibody(0,0)=1./Ip[0];
	In_Ibody(1,1)=1./Ip[1];
	In_Ibody(2,2)=1./Ip[2];

	MatMatProduct(temp,In_Ibody_,Tran_A_,3,3,3);
	MatMatProduct(Ibody_,ITran_A_,temp,3,3,3);   /*      A-1.I-1_body.A  */


	if(P_shape==Ellipsoid)
	{
	    theta=0.; phi=0.5*PI;
	    Function_ellipsoid(pn, theta, phi, &output[0].v1[0]);
	    count=0;

	    phi=-0.729728;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn, theta, phi, &output[count].v1[0]);
	    }
	    phi=-0.339837;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn, theta, phi, &output[count].v1[0]);
	    }
	    phi=0.;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn, theta, phi, &output[count].v1[0]);
	    }
	    phi=0.339837;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn, theta, phi, &output[count].v1[0]);
	    }
	    phi=0.729728;	
	    for(j=0; j<6; j++)
	    {
		    count++;
		    theta=PI*j/3.;
		    Function_ellipsoid(pn, theta, phi, &output[count].v1[0]);
	    }
	
	    theta=0.; phi=-0.5*PI;
	    Function_ellipsoid(pn, theta, phi, &output[31].v1[0]);
		for(i=0; i<32; i++)
	    {
		    MatVecProduct(&output2[i].v1[0], ITran_A_, &output[i].v1[0], 3, 3);
		    for(j=0; j<3; j++)
		    {
			    xyz_EPS(i+1,j+1) = output2[i].v1[j] + xyzPc[j];
		    }
	    }
	}
	else if(P_shape==RBC)
	{
		theta=0.; phi=0.;
	    Function_ellipsoid(pn, theta, phi, &output[0].v1[0]);
	    count=0;

		for(i=1; i<12; i++)
		{
	        for(j=0; j<24; j++)
	        {
		        count++;
			    phi=PI*i/12.;
		        theta=PI*j/12.;
		        Function_ellipsoid(pn, theta, phi, &output[count].v1[0]);
			}
	    }
		count++;
		theta=0.; phi=PI;
	    Function_ellipsoid(pn, theta, phi, &output[count].v1[0]);
		for(i=0; i<266; i++)
    	{
		    MatVecProduct(&output2[i].v1[0], ITran_A_, &output[i].v1[0], 3, 3);
		    for(j=0; j<3; j++)
		    {
			    xyz_EPS(i+1,j+1) = output2[i].v1[j] + xyzPc[j];
		    }
	    }

	}

	y1[0]=0.; y1[1]=1.0; y1[2]=0.;
	MatVecProduct(&y2[0], ITran_A_, &y1[0], 3, 3);  
}


/**************************************************************************/
void Make_ellipsoid_GVX(double Vp[], double Vfluid[],double  omegap[])
/**************************************************************************/
{
	double stiff_max=3.2e-4;
	
    Th_[0]=16.*PI*mu*Minor_a3*Beta_ab/(3.*(beta_ab2*Beta_ab0+Gamma_ab0))*( (beta_ab2-1.)*dzy + (beta_ab2+1)*(wzy-omegap[0]));
	Th_[1]=32.*PI*mu*Minor_a3*Beta_ab/(3.*(Gamma_ab0+Alpha_ab0))*(wxz-omegap[1]);
	Th_[2]=16.*PI*mu*Minor_a3*Beta_ab/(3.*(beta_ab2*Beta_ab0+Alpha_ab0))*( (1.- beta_ab2)*dyx + (beta_ab2+1)*(wyx-omegap[2]));

	GVX_E(0) = -mu*PI*R*( KMat(1,1)*(Vp[0] - Vfluid[0]) + KMat(1,2)*(Vp[1] - Vfluid[1]) + KMat(1,3)*(Vp[2] - Vfluid[2]))/Mp  + (1.-alpha)*F_grav(0);
	GVX_E(1) = -mu*PI*R*( KMat(2,1)*(Vp[0] - Vfluid[0]) + KMat(2,2)*(Vp[1] - Vfluid[1]) + KMat(2,3)*(Vp[2] - Vfluid[2]))/Mp  + (1.-alpha)*F_grav(1); 
	GVX_E(2) = -mu*PI*R*( KMat(3,1)*(Vp[0] - Vfluid[0]) + KMat(3,2)*(Vp[1] - Vfluid[1]) + KMat(3,3)*(Vp[2] - Vfluid[2]))/Mp  + (1.-alpha)*F_grav(2);	

	GVX_E(3) = omegap[1]*omegap[2]*(Ip[1]-Ip[2])/Ip[0] + Th_[0]/Ip[0];
	GVX_E(4) = Th_[1]/Ip[1];
	GVX_E(5) = omegap[0]*omegap[1]*(Ip[0]-Ip[1])/Ip[2] + Th_[2]/Ip[2]; 

    repusive_dist_wall=sqrt(GVX_E(0)*GVX_E(0)+GVX_E(1)*GVX_E(1)+GVX_E(2)*GVX_E(2))*Mp/stiff_max;
}
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/


/**************************************************************************/
void  Data_trasfer1(int i)
/**************************************************************************/
{
	int m;

    for(m=0; m<Nb; m++) 
	{
		uP(1,m)= FPVelU(i,m);  
	    vP(1,m)= FPVelV(i,m);
	    wP(1,m)= FPVelW(i,m);

		xP(1,m)=FPLoX(i,m);
		yP(1,m)=FPLoY(i,m);
		zP(1,m)=FPLoZ(i,m);
		if(P_shape==Ellipsoid ) 
		{
			oX(1,m)=FPox(i,m);
			oY(1,m)=FPoy(i,m);
			oZ(1,m)=FPoz(i,m);
			eps1_TR(1,m)=FPeps1(i,m);
			eps2_TR(1,m)=FPeps2(i,m);
			eps3_TR(1,m)=FPeps3(i,m);
			eta_TR(1,m)=FPeps4(i,m);
		}		
	}
	Lo_init=DepositP(i,0);
	TStep(1)=TStep(iPath+1);
	
}

/**************************************************************************/
int main(int argc, char *argv[])
/**************************************************************************/
{
	double t,  t1;
	int i, j, k, p, m, ca;

	int max_data[4];

	
	real oxyz[3];
	char drtry0[250], drtry[250];	
	getcwd(drtry0,250);
    strcpy(drtry, drtry0);
 	
	loadgeom0();
	MPI_Init (&argc, &argv);
	MPI_Comm_rank (MPI_COMM_WORLD, &id);
	MPI_Comm_size (MPI_COMM_WORLD, &p);
	printf("\n id= %d, p= %d  \n",id,p);
	strcat(drtry,"\\Input_");
	strcat(drtry,jobname);
    chdir(drtry);

	loadgeom1_search(jobname,max_data);
	MXC=max_data[0];
	MXV=max_data[1];
	bcount=max_data[2];
	MXCC=max_data[3];

	loadgeom1();
	Deposit_=new int[MXC];

	for(j=1; j<=MXC; j++)
	{
		Deposit(j)=0; 
	}
	loadgeom2();

    for(j=1; j<=MXC; j++)  Deposit(j)=0; 
	loadCFDdata();	
	loadSeed();

	

	strcpy(drtry, drtry0);
	strcat(drtry,"\\Output_");
    strcat(drtry,jobname);
    mkdir(drtry);
	chdir(drtry);
	f2=fopen("screen.out","w");
	for(i=s_np; i<=e_np; i += inc_np)
    {
		for(m=0; m<Nb; m++)
		{
		   FPLoX(i,m)=0.;
		   FPLoY(i,m)=0.;
		   FPLoZ(i,m)=0.;
		}
	}
    loadDeposition();
 if(TrackWrite) 
 {
	tetra_uvw_=new double[12];
	tetra_xyz_=new double[12];
	tetra_t_  =new double[4];

	 GravityForce();
     for(k=0; k<3; k++)   oxyz[k]=0.;

 for(k=s_time; k<=e_time; k +=1)
 {
	 t=TimeStep*k;
	
     for(i=id*inc_np+s_np; i<=e_np; i += (inc_np*p))
	 {
    	ShearMax=smallest;
        SymCount=0;
    	WallCount=0;
		P_shape=celltype(i);
		if(P_shape==Ellipsoid || P_shape==RBC)     /* Ellipsoid & RBC  */
	    {
			Make_Elliptic_Init(i);
		    Make_Flagellar_Init();
		    Nb=1;
		}
	    else if(P_shape==DNA)
	    {
			Make_DNA_Init();
	    }
		else if(P_shape==0)
	    {
			Nb=1;
	    }
		for(m=0; m<Nb; m++)   DepositP(i,m) = 0; 	
		
		if(RV==1)
		{
			Vo =  Vpvar(i);
            Mp =  Mpvar(i);
			if(P_shape==Sphere)
			{
				R=Rpvar1(i);   // This means longest length of the particle
			}
			else if(P_shape==Ellipsoid)
			{
				R=Minor_a;
				Rbead=0.57e-6;
				Ra=Minor_a+0.5*Rbead;
				Rb=Major_b+0.5*Rbead;
			}
			if(P_shape==Ellipsoid)   
			{
				Ip[0]=Ipx(i);
				Ip[1]=Ipy(i);
				Ip[2]=Ipz(i);
			}
            if(NEWTONIAN==1) ff= ffpvar(i);
		}
	
		xP(1,0)=SeedX(i);
		yP(1,0)=SeedY(i);
		zP(1,0)=SeedZ(i);
		Ptype(i) = ImposeInletVel(i,t, Lo_Seed);
        if(Ptype(i)) 
		{
			ca=0;
			AGAIN=0;
			if(P_shape==Ellipsoid)   
			{
				for(k=0; k<3; k++)   
				{
					InOxyz(k)=0.;
				}
				for(m=0; m<Nb; m++)
				{
					oX(1,m)=0.;
					oY(1,m)=0.;
					oZ(1,m)=0.;

					OrienX(1,m)=0.;
					OrienY(1,m)=-1.;
					OrienZ(1,m)=0.;
				}
				Direct_cosine();
			}
			
            Brown_c=i;
			Make_gaussdev();

			if(Restart==1)
		    {
			    for(m=0; m<Nb; m++)  ReadTrack_Restart(t,i,m);
		    }
			else
			{
				for(m=0; m<Nb; m++)  Slope(1,m)=0.;
			}
again:	
			if(AGAIN==1)
			{
				Data_trasfer1(i);
			}
			  
			if(AGAIN==1)    ParticleSeed(i,time(iPath+1) ,&Slope(iPath+1,0), MaxIter, Lo_init);
			else            ParticleSeed(i,SeedTime(i) ,&Slope(1,0), MaxIter, Lo_Seed);
            if(BFT1==1) 
			{	
				for(m=0; m<Nb; m++)   SaveTrack_BIN(t,i,m);		
			}
			else
			{	
				for(m=0; m<Nb; m++)    SaveTrack(t,i,m);
			}
			if(AGAIN==1)
			{
				ca++;
		        goto again;
			}
			for(m=0; m<Nb; m++)  
			{
			    if(DepositP(i,m)>0) WriteTRP(i,m);
			}
lab2:
			;
		}
        if(i==100)         SaveGDeposit2(id,1);
		else if(i==300)    SaveGDeposit2(id,2);
	    else if(i==500)    SaveGDeposit2(id,3);
		else if (i==700)   SaveGDeposit2(id,4);
		else if (i==1000)  SaveGDeposit2(id,5);
		else if (i==2000)  SaveGDeposit2(id,6);
		else if (i==3000)  SaveGDeposit2(id,7);
		else if (i==4000)  SaveGDeposit2(id,8);
		else if (i==5000)  SaveGDeposit2(id,9);
		else if (i==7500)  SaveGDeposit2(id,10);
		else if (i==10000)  SaveGDeposit2(id,11);
		else if (i==12500)  SaveGDeposit2(id,12);
		else if (i==15000)  SaveGDeposit2(id,13);
	 }

 }

 SaveDeposit(id);
delete  BetaCell_;
delete  Deposit_;
delete  boundCell2_;
delete  subcset_; 
delete tetra_uvw_;
delete tetra_xyz_;
delete tetra_t_;
 printf("Process %d is done \n", id);
 printf("!!     Good Job         !!\n", id);
 if(id==0)  SaveGDeposit(id);
 }

 fclose(f2);
 fclose(f3);
 if(tecplot)
 {
	 t1=MovieEndT;
     TecplotMovieGen_BIN(MovieStartT,MovieEndT, MovieDT);
	 tecMacro_MakeMovie(NumMovieFrame );
	 tecMacro_MakeMovie2(NumMovieFrame );
	 tecMacro_MakeFlash(NumMovieFrame );
 }
 delete  CELL;
 delete  CPIT_;
 delete  CellRT_;
 delete  vertex_;
 delete  cbound_;
delete  verU_;
delete  verV_;
delete  verW_;
delete  verT_;
 Bicp_.clear();
 Bface_.clear();
 Bregion_.clear();
 Bound_.clear();
 Bound0_.clear();
 cell_.clear();
 return 0;
}