Changeset 16228


Ignore:
Timestamp:
09/23/13 09:52:31 (11 years ago)
Author:
Mathieu Morlighem
Message:

DEL: removed some legacy code

Location:
issm/trunk-jpl/src/c
Files:
2 deleted
16 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/CMakeLists.txt

    r15480 r16228  
    517517                                        ./toolkits/petsc/patches/PetscMatrixToDoubleMatrix.cpp
    518518                                        ./toolkits/petsc/patches/PetscVectorToDoubleVector.cpp
    519                                         ./toolkits/petsc/patches/VecDuplicatePatch.cpp
    520519                                        ./toolkits/petsc/patches/KSPFree.cpp
    521520                                        ./toolkits/petsc/patches/MatFree.cpp

  • issm/trunk-jpl/src/c/Makefile.am

    r16226 r16228  
    197197                                        ./shared/Exceptions/exceptions.h\
    198198                                        ./shared/Exceptions/Exceptions.cpp\
    199                                         ./shared/Exceptions/exprintf.cpp\
    200199                                        ./shared/Sorting/binary_search.cpp\
    201200                                        ./shared/Sorting/sorting.h\
    … …  
    770769                                        ./toolkits/petsc/patches/PetscMatrixToDoubleMatrix.cpp\
    771770                                        ./toolkits/petsc/patches/PetscVectorToDoubleVector.cpp\
    772                                         ./toolkits/petsc/patches/VecDuplicatePatch.cpp\
    773771                                        ./toolkits/petsc/patches/KSPFree.cpp\
    774772                                        ./toolkits/petsc/patches/MatFree.cpp\

  • issm/trunk-jpl/src/c/bamg/Mesh.cpp

    r16200 r16228  
    41824182}
    41834183/*}}}*/
    4184         /*FUNCTION Mesh::SplitElement{{{*/
    4185         int  Mesh::SplitElement(int choice){
    4186                 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshQuad.cpp/SplitElement)*/
    4187 
    4188                 long int verbose=0;
    4189 
    4190                 Direction NoDirOfSearch;
    4191                 const  int withBackground = &BTh != this && &BTh;
    4192 
    4193                 TrianglesRenumberBySubDomain();
    4194                 //int nswap =0;
    4195                 const long nfortria( choice ? 4 : 6);
    4196                 if(withBackground)
    4197                   {
    4198                         BTh.SetVertexFieldOn();
    4199                         SetVertexFieldOnBTh();
    4200                   }
    4201                 else
    4202                  BTh.SetVertexFieldOn();
    4203 
    4204                 long newnbt=0,newnbv=0;
    4205                 long * kedge = 0;
    4206                 long newnbq=nbq;
    4207                 long * ksplit= 0, * ksplitarray=0;
    4208                 long kkk=0;
    4209                 int ret =0;
    4210                 if (maxnbv<nbv+nbe) return 1;//   
    4211                 // 1) create  the new points by spliting the internal edges
    4212                 // set the
    4213                 long nbvold = nbv;
    4214                 long nbtold = nbt;
    4215                 long nbtoutold  = nbtout;
    4216                 long  NbEdgeOnGeom=0;
    4217                 long i;
    4218 
    4219                 nbt = nbt - nbtout; // remove all the  the ouside triangles
    4220                 long nbtsave = nbt;
    4221                 Triangle * lastT = triangles + nbt;
    4222                 for (i=0;i<nbe;i++)
    4223                  if(edges[i].GeomEdgeHook) NbEdgeOnGeom++;
    4224                 long newnbe=nbe+nbe;
    4225                 //  long newNbVerticesOnGeomVertex=NbVerticesOnGeomVertex;
    4226                 long newNbVerticesOnGeomEdge=NbVerticesOnGeomEdge+NbEdgeOnGeom;
    4227                 // long newNbVertexOnBThVertex=NbVertexOnBThVertex;
    4228                 long newNbVertexOnBThEdge=withBackground ? NbVertexOnBThEdge+NbEdgeOnGeom:0;
    4229 
    4230                 // do allocation for pointeur to the geometry and background
    4231                 VertexOnGeom * newVerticesOnGeomEdge = new VertexOnGeom[newNbVerticesOnGeomEdge];
    4232                 VertexOnEdge *newVertexOnBThEdge = newNbVertexOnBThEdge ?  new VertexOnEdge[newNbVertexOnBThEdge]:0;
    4233                 if (NbVerticesOnGeomEdge)
    4234                  memcpy(newVerticesOnGeomEdge,VerticesOnGeomEdge,sizeof(VertexOnGeom)*NbVerticesOnGeomEdge);
    4235                 if (NbVertexOnBThEdge)
    4236                  memcpy(newVertexOnBThEdge,VertexOnBThEdge,sizeof(VertexOnEdge)*NbVertexOnBThEdge);
    4237                 Edge *newedges = new Edge [newnbe];
    4238                 //  memcpy(newedges,edges,sizeof(Edge)*nbe);
    4239                 SetOfEdges4 * edge4= new SetOfEdges4(nbe,nbv);
    4240                 long k=nbv;
    4241                 long kk=0;
    4242                 long kvb = NbVertexOnBThEdge;
    4243                 long kvg = NbVerticesOnGeomEdge;
    4244                 long ie =0;
    4245                 Edge ** edgesGtoB=0;
    4246                 if (withBackground)
    4247                  edgesGtoB= BTh.MakeGeomEdgeToEdge();
    4248                 long ferr=0;
    4249                 for (i=0;i<nbe;i++)
    4250                  newedges[ie].GeomEdgeHook=0;
    4251 
    4252                 for (i=0;i<nbe;i++)
    4253                   {
    4254                         GeomEdge *ong =  edges[i].GeomEdgeHook;
    4255 
    4256                         newedges[ie]=edges[i];
    4257                         newedges[ie].adj[0]=newedges+(edges[i].adj[0]-edges) ;
    4258                         newedges[ie].adj[1]=newedges + ie +1;
    4259                         R2 A = edges[i][0],B = edges[i][1];
    4260 
    4261                         kk += (i == edge4->SortAndAdd(GetId(edges[i][0]),GetId(edges[i][1])));
    4262                         if (ong) // a geometrical edges
    4263                           {
    4264                                 if (withBackground){
    4265                                         // walk on back ground mesh
    4266                                         //  newVertexOnBThEdge[ibe++] = VertexOnEdge(vertices[k],bedge,absicsseonBedge);
    4267                                         // a faire -- difficile
    4268                                         // the first PB is to now a background edge between the 2 vertices
    4269                                         if (!edgesGtoB){
    4270                                                 _error_("!edgesGtoB");
    4271                                         }
    4272                                         ong= ProjectOnCurve(*edgesGtoB[Gh.GetId(edges[i].GeomEdgeHook)],
    4273                                                                 edges[i][0],edges[i][1],0.5,vertices[k],
    4274                                                                 newVertexOnBThEdge[kvb],
    4275                                                                 newVerticesOnGeomEdge[kvg++]);
    4276                                         vertices[k].ReferenceNumber= edges[i].ReferenceNumber;
    4277                                         vertices[k].DirOfSearch =   NoDirOfSearch;       
    4278                                         ;
    4279                                         // get the Info on background mesh
    4280                                         double s =        newVertexOnBThEdge[kvb];
    4281                                         BamgVertex &  bv0  = newVertexOnBThEdge[kvb][0];
    4282                                         BamgVertex &  bv1  = newVertexOnBThEdge[kvb][1];
    4283                                         // compute the metrix of the new points
    4284                                         vertices[k].m =  Metric(1-s,bv0,s,bv1);
    4285                                         kvb++;
    4286                                   }
    4287                                 else
    4288                                   {
    4289                                         ong=Gh.ProjectOnCurve(edges[i],
    4290                                                                 0.5,vertices[k],newVerticesOnGeomEdge[kvg++]);
    4291                                         // vertices[k].i = R2ToI2( vertices[k].r);
    4292                                         vertices[k].ReferenceNumber = edges[i].ReferenceNumber;
    4293                                         vertices[k].DirOfSearch = NoDirOfSearch;
    4294                                         vertices[k].m =  Metric(0.5,edges[i][0],0.5,edges[i][1]);             
    4295                                   } 
    4296                           }
    4297                         else // straigth line edge ---
    4298                           {
    4299                                 vertices[k].r = ((R2) edges[i][0] + (R2)  edges[i][1] )*0.5;
    4300                                 vertices[k].m =  Metric(0.5,edges[i][0],0.5,edges[i][1]);
    4301                                 vertices[k].GeomEdgeHook = 0;
    4302                           }
    4303                         //vertices[k].i = R2ToI2( vertices[k].r);
    4304                         R2 AB =  vertices[k].r;
    4305                         R2 AA = (A+AB)*0.5;
    4306                         R2 BB = (AB+B)*0.5;
    4307                         vertices[k].ReferenceNumber = edges[i].ReferenceNumber;
    4308                         vertices[k].DirOfSearch = NoDirOfSearch;
    4309 
    4310                         newedges[ie].GeomEdgeHook = Gh.Containing(AA,ong);
    4311                         newedges[ie++].v[1]=vertices+k;
    4312 
    4313                         newedges[ie]=edges[i];
    4314                         newedges[ie].adj[0]=newedges + ie -1;
    4315                         newedges[ie].adj[1]=newedges+(edges[i].adj[1]-edges) ;
    4316                         newedges[ie].GeomEdgeHook =  Gh.Containing(BB,ong);
    4317                         newedges[ie++].v[0]=vertices+k;
    4318                         k++;
    4319                   }
    4320                 if (edgesGtoB) delete [] edgesGtoB;
    4321                 edgesGtoB=0;
    4322 
    4323                 newnbv=k;
    4324                 newNbVerticesOnGeomEdge=kvg;
    4325                 if (newnbv> maxnbv) goto Error;// bug
    4326 
    4327                 nbv = k;
    4328 
    4329                 kedge = new long[3*nbt+1];
    4330                 ksplitarray = new long[nbt+1];
    4331                 ksplit = ksplitarray +1; // because ksplit[-1] == ksplitarray[0]
    4332 
    4333                 for (i=0;i<3*nbt;i++)
    4334                  kedge[i]=-1;
    4335 
    4336                 // 
    4337 
    4338                 for (i=0;i<nbt;i++) {
    4339                         Triangle & t = triangles[i];
    4340                         if (!t.link){
    4341                                 _error_("!t.link");
    4342                         }
    4343                         for(int j=0;j<3;j++)
    4344                           {
    4345                                 const AdjacentTriangle ta = t.Adj(j);
    4346                                 const Triangle & tt = ta;
    4347                                 if (&tt >= lastT)
    4348                                  t.SetAdj2(j,0,0);// unset adj
    4349                                 const BamgVertex & v0 = t[VerticesOfTriangularEdge[j][0]];
    4350                                 const BamgVertex & v1 = t[VerticesOfTriangularEdge[j][1]];
    4351                                 long  ke =edge4->SortAndFind(GetId(v0),GetId(v1));
    4352                                 if (ke>0)
    4353                                   {
    4354                                         long ii = GetId(tt);
    4355                                         int  jj = ta;
    4356                                         long ks = ke + nbvold;
    4357                                         kedge[3*i+j] = ks;
    4358                                         if (ii<nbt) // good triangle
    4359                                          kedge[3*ii+jj] = ks;
    4360                                         BamgVertex &A=vertices[ks];
    4361                                         double aa,bb,cc,dd;
    4362                                         if ((dd=Area2(v0.r,v1.r,A.r)) >=0){
    4363                                                 // warning PB roundoff error
    4364                                                 if (t.link && ( (aa=Area2( A.r    , t[1].r , t[2].r )) < 0.0
    4365                                                                                 ||   (bb=Area2( t[0].r , A.r    , t[2].r )) < 0.0 
    4366                                                                                 ||   (cc=Area2( t[0].r , t[1].r , A.r    )) < 0.0)){
    4367                                                         _printf_(ke + nbvold << " not in triangle " << i << " In= " << !!t.link << " " << aa << " " << bb << " " << cc << " " << dd << "\n");
    4368                                                         _error_("Number of triangles with P2 interpolation Problem");
    4369                                                 }
    4370                                         }
    4371                                         else {
    4372                                                 if (tt.link && ( (aa=Area2( A.r     , tt[1].r , tt[2].r )) < 0
    4373                                                                                 ||   (bb=Area2( tt[0].r , A.r     , tt[2].r )) < 0
    4374                                                                                 ||   (cc=Area2( tt[0].r , tt[1].r , A.r     )) < 0)){
    4375                                                         _printf_(ke + nbvold << " not in triangle " << ii << " In= " << !!tt.link << " " << aa << " " << bb << " " << cc << " " << dd << "\n");
    4376                                                         _error_("Number of triangles with P2 interpolation Problem");
    4377                                                 }
    4378                                         }
    4379                                   }
    4380                           }
    4381                 }
    4382 
    4383                 for (i=0;i<nbt;i++){
    4384                         ksplit[i]=1; // no split by default
    4385                         const Triangle & t = triangles[ i];
    4386                         int nbsplitedge =0;
    4387                         int nbinvisible =0;
    4388                         int invisibleedge=0;
    4389                         int kkk[3];     
    4390                         for (int j=0;j<3;j++)
    4391                           {
    4392                                 if (t.Hidden(j)) invisibleedge=j,nbinvisible++;
    4393 
    4394                                 const AdjacentTriangle ta = t.Adj(j);
    4395                                 const Triangle & tt = ta;
    4396 
    4397                                 const BamgVertex & v0 = t[VerticesOfTriangularEdge[j][0]];
    4398                                 const BamgVertex & v1 = t[VerticesOfTriangularEdge[j][1]];
    4399                                 if ( kedge[3*i+j] < 0)
    4400                                   {
    4401                                         long  ke =edge4->SortAndFind(GetId(v0),GetId(v1));
    4402                                         if (ke<0) // new
    4403                                           {
    4404                                                 if (&tt) // internal triangles all the boundary
    4405                                                   { // new internal edges
    4406                                                         long ii = GetId(tt);
    4407                                                         int  jj = ta;
    4408 
    4409                                                         kedge[3*i+j]=k;// save the vertex number
    4410                                                         kedge[3*ii+jj]=k;
    4411                                                         if (k<maxnbv)
    4412                                                           {
    4413                                                                 vertices[k].r = ((R2) v0+(R2) v1 )/2;
    4414                                                                 //vertices[k].i = R2ToI2( vertices[k].r);
    4415                                                                 vertices[k].ReferenceNumber=0;
    4416                                                                 vertices[k].DirOfSearch =NoDirOfSearch;
    4417                                                                 vertices[k].m =  Metric(0.5,v0,0.5,v1);
    4418                                                           }
    4419                                                         k++;
    4420                                                         kkk[nbsplitedge++]=j;                 
    4421                                                   } // tt
    4422                                                 else
    4423                                                  _error_("Bug...");
    4424                                           } // ke<0           
    4425                                         else
    4426                                           { // ke >=0
    4427                                                 kedge[3*i+j]=nbvold+ke;
    4428                                                 kkk[nbsplitedge++]=j;// previously splited
    4429                                           }
    4430                                   }
    4431                                 else
    4432                                  kkk[nbsplitedge++]=j;// previously splited
    4433 
    4434                           }
    4435                         if (nbinvisible>=2){
    4436                                 _error_("nbinvisible>=2");
    4437                         }
    4438                         switch (nbsplitedge) {
    4439                                 case 0: ksplit[i]=10; newnbt++; break;   // nosplit
    4440                                 case 1: ksplit[i]=20+kkk[0];newnbt += 2; break; // split in 2
    4441                                 case 2: ksplit[i]=30+3-kkk[0]-kkk[1];newnbt += 3; break; // split in 3
    4442                                 case 3:
    4443                                                   if (nbinvisible) ksplit[i]=40+invisibleedge,newnbt += 4;
    4444                                                   else   ksplit[i]=10*nfortria,newnbt+=nfortria;
    4445                                                   break;
    4446                         }
    4447                         if (ksplit[i]<40){
    4448                                 _error_("ksplit[i]<40");
    4449                         }
    4450                   }
    4451                 //  now do the element split
    4452                 newnbq = 4*nbq;
    4453                 nbv = k;
    4454                 kkk = nbt;
    4455                 ksplit[-1] = nbt;
    4456                 // look on  old true  triangles
    4457 
    4458                 for (i=0;i<nbtsave;i++){
    4459                         int  nbmkadj=0;
    4460                         long mkadj [100];
    4461                         mkadj[0]=i;
    4462                         long kk=ksplit[i]/10;
    4463                         int  ke=(int) (ksplit[i]%10);
    4464                         if (kk>=7 || kk<=0){
    4465                                 _error_("kk>=7 || kk<=0");
    4466                         }
    4467 
    4468                         // def the numbering   k (edge) i vertex
    4469                         int k0 = ke;
    4470                         int k1 = NextEdge[k0];
    4471                         int k2 = PreviousEdge[k0];
    4472                         int i0 = OppositeVertex[k0];
    4473                         int i1 = OppositeVertex[k1];
    4474                         int i2 = OppositeVertex[k2];
    4475 
    4476                         Triangle &t0=triangles[i];
    4477                         BamgVertex * v0=t0(i0);           
    4478                         BamgVertex * v1=t0(i1);           
    4479                         BamgVertex * v2=t0(i2);
    4480 
    4481                         if (nbmkadj>=10){
    4482                                 _error_("nbmkadj>=10");
    4483                         }
    4484                         // --------------------------
    4485                         AdjacentTriangle ta0(t0.Adj(i0)),ta1(t0.Adj(i1)),ta2(t0.Adj(i2));
    4486                         // save the flag Hidden
    4487                         int hid[]={t0.Hidden(0),t0.Hidden(1),t0.Hidden(2)};
    4488                         // un set all adj -- save Hidden flag --
    4489                         t0.SetAdj2(0,0,hid[0]);
    4490                         t0.SetAdj2(1,0,hid[1]);
    4491                         t0.SetAdj2(2,0,hid[2]);
    4492                         // --  remake
    4493                         switch  (kk) {
    4494                                 case 1: break;// nothing
    4495                                 case 2: //
    4496                                                   {
    4497                                                         Triangle &t1=triangles[kkk++];
    4498                                                         t1=t0;
    4499                                                         if (kedge[3*i+i0]<0){
    4500                                                                 _error_("kedge[3*i+i0]<0");
    4501                                                         }
    4502                                                         BamgVertex * v3 = vertices + kedge[3*i+k0];
    4503 
    4504                                                         t0(i2) = v3;
    4505                                                         t1(i1) = v3;
    4506                                                         t0.SetAllFlag(k2,0);
    4507                                                         t1.SetAllFlag(k1,0);
    4508                                                   }
    4509                                                 break;
    4510                                 case 3: //
    4511                                                   {
    4512                                                         Triangle &t1=triangles[kkk++];
    4513                                                         Triangle &t2=triangles[kkk++];
    4514                                                         t2=t1=t0;
    4515                                                         if (kedge[3*i+k1]<0){
    4516                                                                 _error_("kedge[3*i+k1]<0");
    4517                                                         }
    4518                                                         if (kedge[3*i+k2]<0){
    4519                                                                 _error_("kedge[3*i+k2]<0");
    4520                                                         }
    4521 
    4522                                                         BamgVertex * v01 = vertices + kedge[3*i+k2];
    4523                                                         BamgVertex * v02 = vertices + kedge[3*i+k1];
    4524                                                         t0(i1) = v01;
    4525                                                         t0(i2) = v02;
    4526                                                         t1(i2) = v02;
    4527                                                         t1(i0) = v01;
    4528                                                         t2(i0) = v02;
    4529                                                         t0.SetAllFlag(k0,0);
    4530                                                         t1.SetAllFlag(k1,0);
    4531                                                         t1.SetAllFlag(k0,0);
    4532                                                         t2.SetAllFlag(k2,0);
    4533                                                   }
    4534                                                 break;
    4535                                 case 4: //
    4536                                 case 6: // split in 4
    4537                                                   {
    4538                                                         Triangle &t1=triangles[kkk++];
    4539                                                         Triangle &t2=triangles[kkk++];
    4540                                                         Triangle &t3=triangles[kkk++];
    4541                                                         t3=t2=t1=t0;
    4542                                                         if (kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0){
    4543                                                                 _error_("kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0");
    4544                                                         }
    4545                                                         BamgVertex * v12 = vertices + kedge[3*i+k0];
    4546                                                         BamgVertex * v02 = vertices + kedge[3*i+k1];
    4547                                                         BamgVertex * v01 = vertices + kedge[3*i+k2];
    4548                                                         t0(i1) = v01;
    4549                                                         t0(i2) = v02;
    4550                                                         t0.SetAllFlag(k0,hid[k0]);
    4551 
    4552                                                         t1(i0) = v01;
    4553                                                         t1(i2) = v12;
    4554                                                         t0.SetAllFlag(k1,hid[k1]);
    4555 
    4556                                                         t2(i0) = v02;
    4557                                                         t2(i1) = v12;
    4558                                                         t2.SetAllFlag(k2,hid[k2]);
    4559 
    4560                                                         t3(i0) = v12;
    4561                                                         t3(i1) = v02;
    4562                                                         t3(i2) = v01;
    4563 
    4564                                                         t3.SetAllFlag(0,hid[0]);           
    4565                                                         t3.SetAllFlag(1,hid[1]);           
    4566                                                         t3.SetAllFlag(2,hid[2]);
    4567 
    4568                                                         if ( kk == 6)
    4569                                                           {
    4570 
    4571                                                                 Triangle &t4=triangles[kkk++];
    4572                                                                 Triangle &t5=triangles[kkk++];
    4573 
    4574                                                                 t4 = t3;
    4575                                                                 t5 = t3;
    4576 
    4577                                                                 t0.SetHidden(k0);
    4578                                                                 t1.SetHidden(k1);
    4579                                                                 t2.SetHidden(k2);
    4580                                                                 t3.SetHidden(0);
    4581                                                                 t4.SetHidden(1);
    4582                                                                 t5.SetHidden(2);
    4583 
    4584                                                                 if (nbv < maxnbv )
    4585                                                                   {
    4586                                                                         vertices[nbv].r = ((R2) *v01 + (R2) *v12  + (R2) *v02 ) / 3.0;
    4587                                                                         vertices[nbv].ReferenceNumber =0;
    4588                                                                         vertices[nbv].DirOfSearch =NoDirOfSearch;
    4589                                                                         //vertices[nbv].i = R2ToI2(vertices[nbv].r);
    4590                                                                         double a3[]={1./3.,1./3.,1./3.};
    4591                                                                         vertices[nbv].m = Metric(a3,v0->m,v1->m,v2->m);
    4592                                                                         BamgVertex * vc =  vertices +nbv++;
    4593                                                                         t3(i0) = vc;
    4594                                                                         t4(i1) = vc;
    4595                                                                         t5(i2) = vc;
    4596 
    4597                                                                   }
    4598                                                                 else
    4599                                                                  goto Error;
    4600                                                           }
    4601 
    4602                                                   }
    4603                                                 break;         
    4604                         }
    4605 
    4606                         // save all the new triangles
    4607                         mkadj[nbmkadj++]=i;
    4608                         long jj;
    4609                         if (t0.link)
    4610                          for (jj=nbt;jj<kkk;jj++)
    4611                                 {
    4612                                  triangles[jj].link=t0.link;
    4613                                  t0.link= triangles+jj;
    4614                                  mkadj[nbmkadj++]=jj;
    4615                                 }
    4616                         if (nbmkadj>13){// 13 = 6 + 4 +
    4617                                 _error_("nbmkadj>13");
    4618                         }
    4619 
    4620                         if (kk==6)  newnbq+=3;
    4621                         for (jj=ksplit[i-1];jj<kkk;jj++) nbt = kkk;
    4622                         ksplit[i]= nbt; // save last adresse of the new triangles
    4623                         kkk = nbt;
    4624                   }
    4625 
    4626                 for (i=0;i<nbv;i++) vertices[i].m = vertices[i].m*2.;
    4627 
    4628                 if(withBackground)
    4629                  for (i=0;i<BTh.nbv;i++)
    4630                   BTh.vertices[i].m =  BTh.vertices[i].m*2.;
    4631 
    4632                 ret = 2;
    4633                 if (nbt>= maxnbt) goto Error; // bug
    4634                 if (nbv>= maxnbv) goto Error; // bug
    4635                 // generation of the new triangles
    4636 
    4637                 SetIntCoor("In SplitElement");
    4638 
    4639                 CreateSingleVertexToTriangleConnectivity();
    4640                 if(withBackground)
    4641                  BTh.CreateSingleVertexToTriangleConnectivity();
    4642 
    4643                 delete [] edges;
    4644                 edges = newedges;
    4645                 nbe = newnbe;
    4646                 nbq = newnbq;
    4647 
    4648                 for (i=0;i<nbsubdomains;i++)
    4649                   {
    4650                         long k = subdomains[i].edge- edges;
    4651                         subdomains[i].edge =  edges+2*k; // spilt all edge in 2
    4652                   }
    4653 
    4654                 if (ksplitarray) delete [] ksplitarray;
    4655                 if (kedge) delete [] kedge;
    4656                 if (edge4) delete edge4;
    4657                 if (VerticesOnGeomEdge) delete [] VerticesOnGeomEdge;
    4658                 VerticesOnGeomEdge= newVerticesOnGeomEdge;
    4659                 if(VertexOnBThEdge) delete []  VertexOnBThEdge;
    4660                 VertexOnBThEdge = newVertexOnBThEdge;
    4661                 NbVerticesOnGeomEdge = newNbVerticesOnGeomEdge;
    4662                 NbVertexOnBThEdge=newNbVertexOnBThEdge;
    4663                 //  CreateSingleVertexToTriangleConnectivity();
    4664 
    4665                 ReconstructExistingMesh();
    4666 
    4667                 if (verbose>2){
    4668                         _printf_("   number of quadrilaterals    = " << nbq << "\n");
    4669                         _printf_("   number of triangles         = " << nbt-nbtout- nbq*2 << "\n");
    4670                         _printf_("   number of outside triangles = " << nbtout << "\n");
    4671                 }
    4672 
    4673                 return 0; //ok
    4674 
    4675 Error:
    4676                 nbv = nbvold;
    4677                 nbt = nbtold;
    4678                 nbtout = nbtoutold;
    4679                 // cleaning memory ---
    4680                 delete [] newedges;
    4681                 if (ksplitarray) delete [] ksplitarray;
    4682                 if (kedge) delete [] kedge;
    4683                 if (newVerticesOnGeomEdge) delete [] newVerticesOnGeomEdge;
    4684                 if (edge4) delete edge4;
    4685                 if(newVertexOnBThEdge) delete []  newVertexOnBThEdge;
    4686 
    4687                 return ret; // ok
    4688         }
    4689         /*}}}*/
    46904184/*FUNCTION Mesh::SplitInternalEdgeWithBorderVertices{{{*/
    46914185long  Mesh::SplitInternalEdgeWithBorderVertices(){

  • issm/trunk-jpl/src/c/bamg/Mesh.h

    r15066 r16228  
    9292                        long SplitInternalEdgeWithBorderVertices();
    9393                        void MakeQuadrangles(double costheta);
    94                         int  SplitElement(int choice);
    9594                        void MakeBamgQuadtree();
    9695                        void NewPoints(Mesh &,BamgOpts* bamgopts,int KeepVertices=1);

  • issm/trunk-jpl/src/c/bamg/SetOfE4.cpp

    r15066 r16228  
    103103        }
    104104        /*}}}*/
    105         /*FUNCTION  SetOfEdges4::newarete{{{*/
    106         long SetOfEdges4::newarete(long k){
    107                 return NbOfEdges == k+1;
    108         }
    109         /*}}}*/
    110105        /*FUNCTION  SetOfEdges4::SortAndAdd{{{*/
    111106        long SetOfEdges4::SortAndAdd (long ii,long jj) {

  • issm/trunk-jpl/src/c/bamg/SetOfE4.h

    r12821 r16228  
    3737                        long i(long k);
    3838                        long j(long k);
    39                         long newarete(long k);
    4039        };
    4140}

  • issm/trunk-jpl/src/c/classes/Loads/Pengrid.cpp

    r16214 r16228  
    820820}
    821821/*}}}*/
    822 /*FUNCTION Pengrid::UpdateInputs {{{*/
    823 void  Pengrid::UpdateInputs(IssmDouble* solution){
    824         _error_("not supported yet!");
    825 }
    826 /*}}}*/

  • issm/trunk-jpl/src/c/classes/Loads/Pengrid.h

    r16188 r16228  
    103103                #endif
    104104                void  ConstraintActivate(int* punstable);
    105                 void  UpdateInputs(IssmDouble* solution);
    106105                void  ResetConstraint(void);
    107106                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Node.cpp

    r16181 r16228  
    574574        return indexing.clone;
    575575
    576 }
    577 /*}}}*/
    578 /*FUNCTION Node::UpdateSpcs {{{*/
    579 void   Node::UpdateSpcs(IssmDouble* ys){
    580 
    581         int count = 0;
    582         for(int i=0;i<this->indexing.gsize;i++){
    583                 if(this->indexing.s_set[i]){
    584                         this->indexing.svalues[i]=ys[this->indexing.sdoflist[count]];
    585                         count++;
    586                 }
    587         }
    588576}
    589577/*}}}*/

  • issm/trunk-jpl/src/c/classes/Node.h

    r16125 r16228  
    7575                void  Activate(void);
    7676                void  Deactivate(void);
    77                 void  UpdateSpcs(IssmDouble* ys);
    7877                void  ReindexingDone(void);
    7978                bool  RequiresDofReindexing(void);

  • issm/trunk-jpl/src/c/classes/matrix/ElementMatrix.cpp

    r15742 r16228  
    587587}
    588588/*}}}*/
    589 /*FUNCTION ElementMatrix::SetDiag{{{*/
    590 void ElementMatrix::SetDiag(IssmDouble scalar){
    591 
    592         int i;
    593 
    594         if(this->nrows!=this->ncols)_error_("need square matrix in input!");
    595 
    596         for(i=0;i<this->nrows;i++){
    597                 this->values[this->ncols*i+i]=scalar;
    598         }
    599 }
    600 /*}}}*/

  • issm/trunk-jpl/src/c/classes/matrix/ElementMatrix.h

    r15688 r16228  
    6565                void Transpose(void);
    6666                void Init(ElementMatrix* Ke);
    67                 void SetDiag(IssmDouble scalar);
    6867};
    6968#endif //#ifndef _ELEMENT_MATRIX_H_

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateDataSets.cpp

    r16181 r16228  
    182182        }
    183183
    184         /*Update Elements and Materials For Control methods*/
     184        /*Update Elements and Materials For Inversions*/
    185185        #ifdef _HAVE_CONTROL_
    186186        UpdateElementsAndMaterialsControl(elements,materials,iomodel);
     187        #endif
     188
     189        /*Update Elements and Materials For Dakota*/
     190        #ifdef _HAVE_DAKOTA_
     191        UpdateElementsAndMaterialsDakota(elements,materials,iomodel);
    187192        #endif
    188193

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/UpdateElementsStressbalance.cpp

    r16223 r16228  
    113113                if(dakota_analysis)elements->InputDuplicate(VzEnum,QmuVzEnum);
    114114                if(isFS){
    115                         iomodel->FetchDataToInput(elements,PressureEnum);
     115                        iomodel->FetchDataToInput(elements,PressureEnum,0.);
    116116                        if(dakota_analysis)elements->InputDuplicate(PressureEnum,QmuPressureEnum);
    117117                }

  • issm/trunk-jpl/src/c/shared/Exceptions/exceptions.h

    r16155 r16228  
    9292};
    9393/*}}}*/
    94 
    95 char* exprintf(const char* format,...);
    96 
    9794#endif

  • issm/trunk-jpl/src/c/toolkits/petsc/patches/petscpatches.h

    r15839 r16228  
    3434void MatMultPatch(Mat A,Vec X, Vec AX,ISSM_MPI_Comm comm);
    3535void MatToSerial(double** poutmatrix,Mat matrix,ISSM_MPI_Comm comm);
    36 void VecDuplicatePatch(Vec* output, Vec input);
    3736Vec  SerialToVec(double* vector,int vector_size);
    3837InsertMode ISSMToPetscInsertMode(InsMode mode);
Note: See TracChangeset for help on using the changeset viewer.