Commits

Lisandro Dalcin committed 861541b

Expose third derivatives of the geometry map in IGAPoint

Comments (0)

Files changed (8)

   PetscReal *gradX[2]; /*0: [nqp][nsd][dim]           */
                        /*1: [nqp][dim][nsd]           */
   PetscReal *hessX[2]; /*0: [nqp][nsd][dim][dim]      */
-                       /*1: [nqp][dim][nsd][nsd       */
+                       /*1: [nqp][dim][nsd][nsd]      */
+  PetscReal *der3X[2]; /*0: [nqp][nsd][dim][dim][dim] */
+                       /*1: [nqp][dim][nsd][nsd][nsd] */
   PetscReal *detS;     /*   [nqp]                     */
   PetscReal *normal;   /*   [nqp][dim]                */
 
                        /*1: [dim][nsd] */
   PetscReal *hessX[2]; /*0: [nsd][dim][dim] */
                        /*1: [dim][nsd][nsd] */
+  PetscReal *der3X[2]; /*0: [nsd][dim][dim][dim] */
+                       /*1: [dim][nsd][nsd][nsd] */
   PetscReal *detS;     /*   [1] */
   PetscReal *normal;   /*   [dim] */
 
      nqp,nen,X,                  &
      M0,M1,M2,M3,                &
      N0,N1,N2,N3,                &
-     dX,G0,G1,H0,H1)             &
+     dX,G0,G1,H0,H1,I0,I1)      &
   bind(C, name="IGA_ShapeFuns_1D")
   use PetIGA
   implicit none
   real   (kind=IGA_REAL_KIND   ), intent(out)   :: G1(dim,dim,nqp)
   real   (kind=IGA_REAL_KIND   ), intent(out)   :: H0(dim,dim,dim,nqp)
   real   (kind=IGA_REAL_KIND   ), intent(out)   :: H1(dim,dim,dim,nqp)
+  real   (kind=IGA_REAL_KIND   ), intent(out)   :: I0(dim,dim,dim,dim,nqp)
+  real   (kind=IGA_REAL_KIND   ), intent(out)   :: I1(dim,dim,dim,dim,nqp)
   integer(kind=IGA_INTEGER_KIND)  :: q
   do q=1,nqp
      call GeometryMap(&
           nen,X,&
           M0(:,q),M1(:,:,q),M2(:,:,q),M3(:,:,q),&
           N0(:,q),N1(:,:,q),N2(:,:,q),N3(:,:,q),&
-          dX(q),G0(:,:,q),G1(:,:,q),H0(:,:,:,q),H1(:,:,:,q))
+          dX(q),&
+          G0(:,:,q),G1(:,:,q),&
+          H0(:,:,:,q),H1(:,:,:,q),&
+          I0(:,:,:,:,q),I1(:,:,:,:,q))
   end do
 contains
 include 'petigageo.f90.in'
      nqp,nen,X,                  &
      M0,M1,M2,M3,                &
      N0,N1,N2,N3,                &
-     dX,G0,G1,H0,H1)             &
+     dX,G0,G1,H0,H1,I0,I1)       &
   bind(C, name="IGA_ShapeFuns_2D")
   use PetIGA
   implicit none
   real   (kind=IGA_REAL_KIND   ), intent(out)   :: G1(dim,dim,nqp)
   real   (kind=IGA_REAL_KIND   ), intent(out)   :: H0(dim,dim,dim,nqp)
   real   (kind=IGA_REAL_KIND   ), intent(out)   :: H1(dim,dim,dim,nqp)
+  real   (kind=IGA_REAL_KIND   ), intent(out)   :: I0(dim,dim,dim,dim,nqp)
+  real   (kind=IGA_REAL_KIND   ), intent(out)   :: I1(dim,dim,dim,dim,nqp)
   integer(kind=IGA_INTEGER_KIND)  :: q
   do q=1,nqp
      call GeometryMap(&
           nen,X,&
           M0(:,q),M1(:,:,q),M2(:,:,q),M3(:,:,q),&
           N0(:,q),N1(:,:,q),N2(:,:,q),N3(:,:,q),&
-          dX(q),G0(:,:,q),G1(:,:,q),H0(:,:,:,q),H1(:,:,:,q))
+          dX(q),&
+          G0(:,:,q),G1(:,:,q),&
+          H0(:,:,:,q),H1(:,:,:,q),&
+          I0(:,:,:,:,q),I1(:,:,:,:,q))
   end do
 contains
 include 'petigageo.f90.in'
      nqp,nen,X,                  &
      M0,M1,M2,M3,                &
      N0,N1,N2,N3,                &
-     dX,G0,G1,H0,H1)             &
+     dX,G0,G1,H0,H1,I0,I1)       &
   bind(C, name="IGA_ShapeFuns_3D")
   use PetIGA
   implicit none
   real   (kind=IGA_REAL_KIND   ), intent(out)   :: G1(dim,dim,nqp)
   real   (kind=IGA_REAL_KIND   ), intent(out)   :: H0(dim,dim,dim,nqp)
   real   (kind=IGA_REAL_KIND   ), intent(out)   :: H1(dim,dim,dim,nqp)
+  real   (kind=IGA_REAL_KIND   ), intent(out)   :: I0(dim,dim,dim,dim,nqp)
+  real   (kind=IGA_REAL_KIND   ), intent(out)   :: I1(dim,dim,dim,dim,nqp)
   integer(kind=IGA_INTEGER_KIND)  :: q
   do q=1,nqp
      call GeometryMap(&
           nen,X,&
           M0(:,q),M1(:,:,q),M2(:,:,q),M3(:,:,q),&
           N0(:,q),N1(:,:,q),N2(:,:,q),N3(:,:,q),&
-          dX(q),G0(:,:,q),G1(:,:,q),H0(:,:,:,q),H1(:,:,:,q))
+          dX(q),&
+          G0(:,:,q),G1(:,:,q),&
+          H0(:,:,:,q),H1(:,:,:,q),&
+          I0(:,:,:,:,q),I1(:,:,:,:,q))
   end do
 contains
 include 'petigageo.f90.in'
   ierr = PetscFree(element->gradX[1]);CHKERRQ(ierr);
   ierr = PetscFree(element->hessX[0]);CHKERRQ(ierr);
   ierr = PetscFree(element->hessX[1]);CHKERRQ(ierr);
+  ierr = PetscFree(element->der3X[0]);CHKERRQ(ierr);
+  ierr = PetscFree(element->der3X[1]);CHKERRQ(ierr);
   ierr = PetscFree(element->detS);CHKERRQ(ierr);
   ierr = PetscFree(element->normal);CHKERRQ(ierr);
 
     ierr = PetscMalloc1(nqp*dim*dim,PetscReal,&element->gradX[1]);CHKERRQ(ierr);
     ierr = PetscMalloc1(nqp*dim*dim*dim,PetscReal,&element->hessX[0]);CHKERRQ(ierr);
     ierr = PetscMalloc1(nqp*dim*dim*dim,PetscReal,&element->hessX[1]);CHKERRQ(ierr);
+    ierr = PetscMalloc1(nqp*dim*dim*dim*dim,PetscReal,&element->der3X[0]);CHKERRQ(ierr);
+    ierr = PetscMalloc1(nqp*dim*dim*dim*dim,PetscReal,&element->der3X[1]);CHKERRQ(ierr);
     ierr = PetscMalloc1(nqp,PetscReal,&element->detS);CHKERRQ(ierr);
     ierr = PetscMalloc1(nqp*dim,PetscReal,&element->normal);CHKERRQ(ierr);
 
     ierr = PetscMemzero(element->gradX[1],sizeof(PetscReal)*nqp*dim*dim);CHKERRQ(ierr);
     ierr = PetscMemzero(element->hessX[0],sizeof(PetscReal)*nqp*dim*dim*dim);CHKERRQ(ierr);
     ierr = PetscMemzero(element->hessX[1],sizeof(PetscReal)*nqp*dim*dim*dim);CHKERRQ(ierr);
+    ierr = PetscMemzero(element->der3X[0],sizeof(PetscReal)*nqp*dim*dim*dim*dim);CHKERRQ(ierr);
+    ierr = PetscMemzero(element->der3X[1],sizeof(PetscReal)*nqp*dim*dim*dim*dim);CHKERRQ(ierr);
     ierr = PetscMemzero(element->detS,    sizeof(PetscReal)*nqp);CHKERRQ(ierr);
     ierr = PetscMemzero(element->normal,  sizeof(PetscReal)*nqp*dim);CHKERRQ(ierr);
     /* */
   point->gradX[1] += dim*dim;
   point->hessX[0] += dim*dim*dim;
   point->hessX[1] += dim*dim*dim;
+  point->der3X[0] += dim*dim*dim*dim;
+  point->der3X[1] += dim*dim*dim*dim;
   point->detS     += 1;
   point->normal   += dim;
 
   point->gradX[1] = element->gradX[1];
   point->hessX[0] = element->hessX[0];
   point->hessX[1] = element->hessX[1];
+  point->der3X[0] = element->der3X[0];
+  point->der3X[1] = element->der3X[1];
   point->detS     = element->detS;
   point->normal   = element->normal;
 
 extern void IGA_ShapeFuns_1D(PetscInt,PetscInt,PetscInt,const PetscReal[],
                              const PetscReal[],const PetscReal[],const PetscReal[],const PetscReal[],
                              PetscReal[],PetscReal[],PetscReal[],PetscReal[],
-                             PetscReal[],PetscReal[],PetscReal[],PetscReal[],PetscReal[]);
+                             PetscReal[],PetscReal[],PetscReal[],PetscReal[],PetscReal[],PetscReal[],PetscReal[]);
 extern void IGA_ShapeFuns_2D(PetscInt,PetscInt,PetscInt,const PetscReal[],
                              const PetscReal[],const PetscReal[],const PetscReal[],const PetscReal[],
                              PetscReal[],PetscReal[],PetscReal[],PetscReal[],
-                             PetscReal[],PetscReal[],PetscReal[],PetscReal[],PetscReal[]);
+                             PetscReal[],PetscReal[],PetscReal[],PetscReal[],PetscReal[],PetscReal[],PetscReal[]);
 extern void IGA_ShapeFuns_3D(PetscInt,PetscInt,PetscInt,const PetscReal[],
                              const PetscReal[],const PetscReal[],const PetscReal[],const PetscReal[],
                              PetscReal[],PetscReal[],PetscReal[],PetscReal[],
-                             PetscReal[],PetscReal[],PetscReal[],PetscReal[],PetscReal[]);
+                             PetscReal[],PetscReal[],PetscReal[],PetscReal[],PetscReal[],PetscReal[],PetscReal[]);
 EXTERN_C_END
 
 #define IGA_Quadrature_ARGS(ID,BD,i) \
     PetscReal *G1 = element->gradX[1];
     PetscReal *H0 = element->hessX[0];
     PetscReal *H1 = element->hessX[1];
+    PetscReal *I0 = element->der3X[0];
+    PetscReal *I1 = element->der3X[1];
     switch (element->dim) {
     case 3: IGA_ShapeFuns_3D(ord,nqp,nen,X,
                              M[0],M[1],M[2],M[3],
                              N[0],N[1],N[2],N[3],
-                             J,G0,G1,H0,H1); break;
+                             J,G0,G1,H0,H1,I0,I1); break;
     case 2: IGA_ShapeFuns_2D(ord,nqp,nen,X,
                              M[0],M[1],M[2],M[3],
                              N[0],N[1],N[2],N[3],
-                             J,G0,G1,H0,H1); break;
+                             J,G0,G1,H0,H1,I0,I1); break;
     case 1: IGA_ShapeFuns_1D(ord,nqp,nen,X,
                              M[0],M[1],M[2],M[3],
                              N[0],N[1],N[2],N[3],
-                             J,G0,G1,H0,H1); break;
+                             J,G0,G1,H0,H1,I0,I1); break;
     }
     for (q=0; q<nqp; q++)
       element->detJac[q] *= J[q];
     PetscReal *G1 = element->gradX[1];
     PetscReal *H0 = element->hessX[0];
     PetscReal *H1 = element->hessX[1];
+    PetscReal *I0 = element->der3X[0];
+    PetscReal *I1 = element->der3X[1];
     PetscReal *S  = element->detS;
     PetscReal *n  = element->normal;
     switch (dim) {
     case 3: IGA_ShapeFuns_3D(ord,nqp,nen,X,
                              M[0],M[1],M[2],M[3],
                              N[0],N[1],N[2],N[3],
-                             J,G0,G1,H0,H1); break;
+                             J,G0,G1,H0,H1,I0,I1); break;
     case 2: IGA_ShapeFuns_2D(ord,nqp,nen,X,
                              M[0],M[1],M[2],M[3],
                              N[0],N[1],N[2],N[3],
-                             J,G0,G1,H0,H1); break;
+                             J,G0,G1,H0,H1,I0,I1); break;
     case 1: IGA_ShapeFuns_1D(ord,nqp,nen,X,
                              M[0],M[1],M[2],M[3],
                              N[0],N[1],N[2],N[3],
-                             J,G0,G1,H0,H1); break;
+                             J,G0,G1,H0,H1,I0,I1); break;
     }
     for (q=0; q<nqp; q++)
       IGA_GetNormal(dim,dir,side,&G0[q*dim*dim],&S[q],&n[q*dim]);

src/petigaftn.F90

      type(C_PTR) :: detX
      type(C_PTR) :: gradX(0:1)
      type(C_PTR) :: hessX(0:1)
+     type(C_PTR) :: der3X(0:1)
      type(C_PTR) :: detS
      type(C_PTR) :: normal
      type(C_PTR) :: shape(0:3)

src/petigageo.f90.in

      nen,X,&
      N0,N1,N2,N3,&
      R0,R1,R2,R3,&
-     dX,X1,E1,X2,E2)
+     dX,X1,E1,X2,E2,X3,E3)
   use PetIGA
   implicit none
   !integer(kind=IGA_INTEGER_KIND),parameter   :: dim = 1,2,3
   real   (kind=IGA_REAL_KIND   ), intent(out) :: E1(dim,dim)
   real   (kind=IGA_REAL_KIND   ), intent(out) :: X2(dim,dim,dim)
   real   (kind=IGA_REAL_KIND   ), intent(out) :: E2(dim,dim,dim)
+  real   (kind=IGA_REAL_KIND   ), intent(out) :: X3(dim,dim,dim,dim)
+  real   (kind=IGA_REAL_KIND   ), intent(out) :: E3(dim,dim,dim,dim)
 
-  real   (kind=IGA_REAL_KIND   )  :: X3(dim,dim,dim,dim)
-  real   (kind=IGA_REAL_KIND   )  :: E3(dim,dim,dim,dim)
   integer(kind=IGA_INTEGER_KIND)  :: node
   integer(kind=IGA_INTEGER_KIND)  :: i, j, k, l
   integer(kind=IGA_INTEGER_KIND)  :: a, b, c, d

test/GeometryMap.c

     AssertEQUAL(F[2][2], 2.0);
   }
   if (dim==2) {
-    PetscInt  i,j,k;
+    PetscInt  a,i,j,k;
     PetscReal G[2][2];
     PetscReal H[2][2][2];
-    ierr = PetscMemcpy(&G[0][0],   p->gradX[0],sizeof(G));CHKERRQ(ierr);
-    ierr = PetscMemcpy(&H[0][0][0],p->hessX[0],sizeof(H));CHKERRQ(ierr);
-    for (k=0;k<dim;k++)
+    PetscReal D[2][2][2][2];
+    ierr = PetscMemcpy(&G[0][0],      p->gradX[0],sizeof(G));CHKERRQ(ierr);
+    ierr = PetscMemcpy(&H[0][0][0],   p->hessX[0],sizeof(H));CHKERRQ(ierr);
+    ierr = PetscMemcpy(&D[0][0][0][0],p->der3X[0],sizeof(D));CHKERRQ(ierr);
+    for (a=0;a<dim;a++)
       for (i=0;i<dim;i++)
         for (j=0;j<dim;j++)
-          AssertEQUAL(H[k][i][j], H[k][j][i]);
+          {
+            AssertEQUAL(H[a][i][j], H[a][j][i]);
+          }
     AssertEQUAL(H[0][0][0], 0.0);
     AssertEQUAL(H[1][0][0], 0.0);
+    for (a=0;a<dim;a++)
+      for (i=0;i<dim;i++)
+        for (j=0;j<dim;j++)
+          for (k=0;k<dim;k++)
+            {
+              AssertEQUAL(D[a][i][j][k], D[a][j][i][k]);
+              AssertEQUAL(D[a][i][j][k], D[a][i][k][j]);
+              AssertEQUAL(D[a][i][j][k], D[a][k][j][i]);
+            }
     {
       PetscReal x  = X[0];
       PetscReal y  = X[1];
     }
   }
   if (dim==3) {
-    PetscInt i,j,k;
+    PetscInt a,i,j,k;
     PetscReal G[3][3];
     PetscReal H[3][3][3];
-    ierr = PetscMemcpy(&G[0][0],   p->gradX[0],sizeof(G));CHKERRQ(ierr);
-    ierr = PetscMemcpy(&H[0][0][0],p->hessX[0],sizeof(H));CHKERRQ(ierr);
-    for (k=0;k<dim;k++)
+    PetscReal D[3][3][3][3];
+    ierr = PetscMemcpy(&G[0][0],      p->gradX[0],sizeof(G));CHKERRQ(ierr);
+    ierr = PetscMemcpy(&H[0][0][0],   p->hessX[0],sizeof(H));CHKERRQ(ierr);
+    ierr = PetscMemcpy(&D[0][0][0][0],p->der3X[0],sizeof(D));CHKERRQ(ierr);
+    for (a=0;a<dim;a++)
       for (i=0;i<dim;i++)
         for (j=0;j<dim;j++)
-          AssertEQUAL(H[k][i][j], H[k][j][i]);
+          {
+            AssertEQUAL(H[a][i][j], H[a][j][i]);
+          }
     AssertEQUAL(H[0][0][0], 0.0);
     AssertEQUAL(H[1][0][0], 0.0);
     AssertEQUAL(H[2][0][0], 0.0);
     AssertEQUAL(H[0][2][2], 0.0);
     AssertEQUAL(H[1][2][2], 0.0);
     AssertEQUAL(H[2][2][2], 0.0);
+    for (a=0;a<dim;a++)
+      for (i=0;i<dim;i++)
+        for (j=0;j<dim;j++)
+          for (k=0;k<dim;k++)
+            {
+              AssertEQUAL(D[a][i][j][k], D[a][j][i][k]);
+              AssertEQUAL(D[a][i][j][k], D[a][i][k][j]);
+              AssertEQUAL(D[a][i][j][k], D[a][k][j][i]);
+            }
     {
       PetscReal x  = X[0];
       PetscReal y  = X[1];
   }
   if (dim==2) {
     PetscInt  nen = p->nen;
-    PetscInt  a,k,i,j;
-    PetscReal (*C)[2] = (PetscReal(*)[2])    p->geometry;
+    PetscInt  a,l,i,j,k;
+    PetscReal (*C)[2] = (PetscReal(*)[2]) p->geometry;
     PetscReal (*N1)[2] = (PetscReal(*)[2]) p->shape[1];
     PetscReal (*N2)[2][2] = (PetscReal(*)[2][2]) p->shape[2];
-    PetscReal G[2][2],H[2][2][2];
+    PetscReal (*N3)[2][2][2] = (PetscReal(*)[2][2][2]) p->shape[3];
+    PetscReal G[2][2],H[2][2][2],D[2][2][2][2];
     ierr = PetscMemzero(&G[0][0],sizeof(G));CHKERRQ(ierr);
     ierr = PetscMemzero(&H[0][0][0],sizeof(H));CHKERRQ(ierr);
+    ierr = PetscMemzero(&D[0][0][0][0],sizeof(D));CHKERRQ(ierr);
+    /* */
     for (a=0;a<nen;a++)
-      for (k=0;k<dim;k++)
+      for (l=0;l<dim;l++)
         for (i=0;i<dim;i++)
-          G[k][i] += C[a][k]*N1[a][i];
+          G[l][i] += C[a][l]*N1[a][i];
     for (a=0;a<nen;a++)
-      for (k=0;k<dim;k++)
+      for (l=0;l<dim;l++)
         for (i=0;i<dim;i++)
           for (j=0;j<dim;j++)
-            H[k][i][j] += C[a][k]*N2[a][i][j];
+            H[l][i][j] += C[a][l]*N2[a][i][j];
+    for (a=0;a<nen;a++)
+      for (l=0;l<dim;l++)
+        for (i=0;i<dim;i++)
+          for (j=0;j<dim;j++)
+            for (k=0;k<dim;k++)
+              D[l][i][j][k] += C[a][l]*N3[a][i][j][k];
+    /* */
     for (i=0;i<dim;i++)
       for (j=0;j<dim;j++)
         if (i==j)
       for (j=0;j<dim;j++)
         for (k=0;k<dim;k++)
           AssertEQUAL(H[i][j][k], 0.0);
+    for (i=0;i<dim;i++)
+      for (j=0;j<dim;j++)
+        for (k=0;k<dim;k++)
+          for (l=0;l<dim;l++)
+            AssertEQUAL(D[i][j][k][l], 0.0);
   }
   if (dim==3) {
     PetscInt  nen = p->nen;
-    PetscInt  a,k,i,j;
-    PetscReal (*C)[3] = (PetscReal(*)[3])    p->geometry;
+    PetscInt  a,l,i,j,k;
+    PetscReal (*C)[3] = (PetscReal(*)[3]) p->geometry;
     PetscReal (*N1)[3] = (PetscReal(*)[3]) p->shape[1];
     PetscReal (*N2)[3][3] = (PetscReal(*)[3][3]) p->shape[2];
-    PetscReal G[3][3],H[3][3][3];
+    PetscReal (*N3)[3][3][3] = (PetscReal(*)[3][3][3]) p->shape[3];
+    PetscReal G[3][3],H[3][3][3],D[3][3][3][3];
     ierr = PetscMemzero(&G[0][0],sizeof(G));CHKERRQ(ierr);
     ierr = PetscMemzero(&H[0][0][0],sizeof(H));CHKERRQ(ierr);
+    ierr = PetscMemzero(&D[0][0][0][0],sizeof(D));CHKERRQ(ierr);
+    /* */
     for (a=0;a<nen;a++)
-      for (k=0;k<dim;k++)
+      for (l=0;l<dim;l++)
         for (i=0;i<dim;i++)
-          G[k][i] += C[a][k]*N1[a][i];
-    for (k=0;k<dim;k++)
-      for (i=0;i<dim;i++)
-        if (k==i) AssertEQUAL(G[k][i], 1.0);
-        else      AssertEQUAL(G[k][i], 0.0);
+          G[l][i] += C[a][l]*N1[a][i];
     for (a=0;a<nen;a++)
-      for (k=0;k<dim;k++)
+      for (l=0;l<dim;l++)
         for (i=0;i<dim;i++)
           for (j=0;j<dim;j++)
-            H[k][i][j] += C[a][k]*N2[a][i][j];
-    for (k=0;k<dim;k++)
-      for (i=0;i<dim;i++)
-        for (j=0;j<dim;j++)
-          AssertEQUAL(H[k][i][j], 0.0);
+            H[l][i][j] += C[a][l]*N2[a][i][j];
+    for (a=0;a<nen;a++)
+      for (l=0;l<dim;l++)
+        for (i=0;i<dim;i++)
+          for (j=0;j<dim;j++)
+            for (k=0;k<dim;k++)
+              D[l][i][j][k] += C[a][l]*N3[a][i][j][k];
+    /* */
+    for (i=0;i<dim;i++)
+      for (j=0;j<dim;j++)
+        if (i==j) AssertEQUAL(G[i][j], 1.0);
+        else      AssertEQUAL(G[i][j], 0.0);
+    for (i=0;i<dim;i++)
+      for (j=0;j<dim;j++)
+        for (k=0;k<dim;k++)
+          AssertEQUAL(H[i][j][k], 0.0);
+    for (i=0;i<dim;i++)
+      for (j=0;j<dim;j++)
+        for (k=0;k<dim;k++)
+          for (l=0;l<dim;l++)
+            AssertEQUAL(D[i][j][k][l], 0.0);
   }
   PetscFunctionReturn(0);
 }
   ierr = IGASetQuadrature(iga,2,8);CHKERRQ(ierr);
 
   ierr = IGASetDim(iga,dim);CHKERRQ(ierr);
+  ierr = IGASetOrder(iga,3);CHKERRQ(ierr);
   ierr = IGASetUp(iga);CHKERRQ(ierr);
 
   iga->rational = PETSC_TRUE;
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.