/[escript]/branches/diaplayground/ripley/src/Brick.cpp
ViewVC logotype

Diff of /branches/diaplayground/ripley/src/Brick.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3702 by caltinay, Fri Dec 2 06:12:32 2011 UTC revision 3757 by caltinay, Fri Jan 6 04:48:27 2012 UTC
# Line 13  Line 13 
13    
14  #include <ripley/Brick.h>  #include <ripley/Brick.h>
15  extern "C" {  extern "C" {
16  #include "paso/SystemMatrixPattern.h"  #include "paso/SystemMatrix.h"
17  }  }
18    
19  #if USE_SILO  #if USE_SILO
# Line 47  Brick::Brick(int n0, int n1, int n2, dou Line 47  Brick::Brick(int n0, int n1, int n2, dou
47      if (m_NX*m_NY*m_NZ != m_mpiInfo->size)      if (m_NX*m_NY*m_NZ != m_mpiInfo->size)
48          throw RipleyException("Invalid number of spatial subdivisions");          throw RipleyException("Invalid number of spatial subdivisions");
49    
50      if (n0%m_NX > 0 || n1%m_NY > 0 || n2%m_NZ > 0)      if ((n0+1)%m_NX > 0 || (n1+1)%m_NY > 0 || (n2+1)%m_NZ > 0)
51          throw RipleyException("Number of elements must be separable into number of ranks in each dimension");          throw RipleyException("Number of elements+1 must be separable into number of ranks in each dimension");
52    
53      // local number of elements      if ((m_NX > 1 && (n0+1)/m_NX<2) || (m_NY > 1 && (n1+1)/m_NY<2) || (m_NZ > 1 && (n2+1)/m_NZ<2))
54      m_NE0 = n0/m_NX;          throw RipleyException("Too few elements for the number of ranks");
55      m_NE1 = n1/m_NY;  
56      m_NE2 = n2/m_NZ;      // local number of elements (including overlap)
57      // local number of nodes (not necessarily owned)      m_NE0 = (m_NX>1 ? (n0+1)/m_NX : n0);
58        if (m_mpiInfo->rank%m_NX>0 && m_mpiInfo->rank%m_NX<m_NX-1)
59            m_NE0++;
60        m_NE1 = (m_NY>1 ? (n1+1)/m_NY : n1);
61        if (m_mpiInfo->rank%(m_NX*m_NY)/m_NX>0 && m_mpiInfo->rank%(m_NX*m_NY)/m_NX<m_NY-1)
62            m_NE1++;
63        m_NE2 = (m_NZ>1 ? (n2+1)/m_NZ : n2);
64        if (m_mpiInfo->rank/(m_NX*m_NY)>0 && m_mpiInfo->rank/(m_NX*m_NY)<m_NZ-1)
65            m_NE2++;
66    
67        // local number of nodes
68      m_N0 = m_NE0+1;      m_N0 = m_NE0+1;
69      m_N1 = m_NE1+1;      m_N1 = m_NE1+1;
70      m_N2 = m_NE2+1;      m_N2 = m_NE2+1;
71    
72      // bottom-left-front node is at (offset0,offset1,offset2) in global mesh      // bottom-left-front node is at (offset0,offset1,offset2) in global mesh
73      m_offset0 = m_NE0*(m_mpiInfo->rank%m_NX);      m_offset0 = (n0+1)/m_NX*(m_mpiInfo->rank%m_NX);
74      m_offset1 = m_NE1*(m_mpiInfo->rank%(m_NX*m_NY)/m_NX);      if (m_offset0 > 0)
75      m_offset2 = m_NE2*(m_mpiInfo->rank/(m_NX*m_NY));          m_offset0--;
76        m_offset1 = (n1+1)/m_NY*(m_mpiInfo->rank%(m_NX*m_NY)/m_NX);
77        if (m_offset1 > 0)
78            m_offset1--;
79        m_offset2 = (n2+1)/m_NZ*(m_mpiInfo->rank/(m_NX*m_NY));
80        if (m_offset2 > 0)
81            m_offset2--;
82    
83      populateSampleIds();      populateSampleIds();
84        createPattern();
85  }  }
86    
87    
# Line 77  string Brick::getDescription() const Line 96  string Brick::getDescription() const
96    
97  bool Brick::operator==(const AbstractDomain& other) const  bool Brick::operator==(const AbstractDomain& other) const
98  {  {
99      if (dynamic_cast<const Brick*>(&other))      const Brick* o=dynamic_cast<const Brick*>(&other);
100          return this==&other;      if (o) {
101            return (RipleyDomain::operator==(other) &&
102                    m_gNE0==o->m_gNE0 && m_gNE1==o->m_gNE1 && m_gNE2==o->m_gNE2
103                    && m_l0==o->m_l0 && m_l1==o->m_l1 && m_l2==o->m_l2
104                    && m_NX==o->m_NX && m_NY==o->m_NY && m_NZ==o->m_NZ);
105        }
106    
107      return false;      return false;
108  }  }
# Line 232  const int* Brick::borrowSampleReferenceI Line 256  const int* Brick::borrowSampleReferenceI
256  {  {
257      switch (fsType) {      switch (fsType) {
258          case Nodes:          case Nodes:
259            case ReducedNodes: //FIXME: reduced
260              return &m_nodeId[0];              return &m_nodeId[0];
261            case DegreesOfFreedom:
262            case ReducedDegreesOfFreedom: //FIXME: reduced
263                return &m_dofId[0];
264          case Elements:          case Elements:
265            case ReducedElements:
266              return &m_elementId[0];              return &m_elementId[0];
267          case FaceElements:          case FaceElements:
268            case ReducedFaceElements:
269              return &m_faceId[0];              return &m_faceId[0];
270          default:          default:
271              break;              break;
# Line 247  const int* Brick::borrowSampleReferenceI Line 277  const int* Brick::borrowSampleReferenceI
277      throw RipleyException(msg.str());      throw RipleyException(msg.str());
278  }  }
279    
280  bool Brick::ownSample(int fsCode, index_t id) const  bool Brick::ownSample(int fsType, index_t id) const
281  {  {
282  #ifdef ESYS_MPI  #ifdef ESYS_MPI
283      if (fsCode == Nodes) {      switch (fsType) {
284          const index_t myFirst=m_nodeDistribution[m_mpiInfo->rank];          case Nodes:
285          const index_t myLast=m_nodeDistribution[m_mpiInfo->rank+1]-1;          case ReducedNodes: //FIXME: reduced
286          return (m_nodeId[id]>=myFirst && m_nodeId[id]<=myLast);              return (m_dofMap[id] < getNumDOF());
287      } else          case DegreesOfFreedom:
288          throw RipleyException("ownSample() only implemented for Nodes");          case ReducedDegreesOfFreedom:
289                return true;
290            case Elements:
291            case ReducedElements:
292                {
293                    // check ownership of element's _last_ node
294                    const index_t x=id%m_NE0 + 1;
295                    const index_t y=id%(m_NE0*m_NE1)/m_NE0 + 1;
296                    const index_t z=id/(m_NE0*m_NE1) + 1;
297                    return (m_dofMap[x + m_N0*y +m_N0*m_N1*z] < getNumDOF());
298                }
299            case FaceElements:
300            case ReducedFaceElements:
301            default:
302                break;
303        }
304    
305        stringstream msg;
306        msg << "ownSample() not implemented for "
307            << functionSpaceTypeAsString(fsType);
308        throw RipleyException(msg.str());
309  #else  #else
310      return true;      return true;
311  #endif  #endif
312  }  }
313    
314    void Brick::setToGradient(escript::Data& out, const escript::Data& cIn) const
315    {
316        escript::Data& in = *const_cast<escript::Data*>(&cIn);
317        const dim_t numComp = in.getDataPointSize();
318        const double h0 = m_l0/m_gNE0;
319        const double h1 = m_l1/m_gNE1;
320        const double h2 = m_l1/m_gNE2;
321        const double C0 = .044658198738520451079;
322        const double C1 = .16666666666666666667;
323        const double C2 = .21132486540518711775;
324        const double C3 = .25;
325        const double C4 = .5;
326        const double C5 = .62200846792814621559;
327        const double C6 = .78867513459481288225;
328    
329        if (out.getFunctionSpace().getTypeCode() == Elements) {
330            /*** GENERATOR SNIP_GRAD_ELEMENTS TOP */
331    #pragma omp parallel for
332            for (index_t k2=0; k2 < m_NE2; ++k2) {
333                for (index_t k1=0; k1 < m_NE1; ++k1) {
334                    for (index_t k0=0; k0 < m_NE0; ++k0) {
335                        const register double* f_000 = in.getSampleDataRO(INDEX3(k0,k1,k2, m_N0,m_N1));
336                        const register double* f_001 = in.getSampleDataRO(INDEX3(k0,k1,k2+1, m_N0,m_N1));
337                        const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,k1,k2+1, m_N0,m_N1));
338                        const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,k1+1,k2+1, m_N0,m_N1));
339                        const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,k1+1,k2, m_N0,m_N1));
340                        const register double* f_011 = in.getSampleDataRO(INDEX3(k0,k1+1,k2+1, m_N0,m_N1));
341                        const register double* f_010 = in.getSampleDataRO(INDEX3(k0,k1+1,k2, m_N0,m_N1));
342                        const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,k1,k2, m_N0,m_N1));
343                        double* o = out.getSampleDataRW(INDEX3(k0,k1,k2,m_NE0,m_NE1));
344                        for (index_t i=0; i < numComp; ++i) {
345                            const double V0=((f_100[i]-f_000[i])*C5 + (f_111[i]-f_011[i])*C0 + (f_101[i]+f_110[i]-f_001[i]-f_010[i])*C1) / h0;
346                            const double V1=((f_110[i]-f_010[i])*C5 + (f_101[i]-f_001[i])*C0 + (f_100[i]+f_111[i]-f_000[i]-f_011[i])*C1) / h0;
347                            const double V2=((f_101[i]-f_001[i])*C5 + (f_110[i]-f_010[i])*C0 + (f_100[i]+f_111[i]-f_000[i]-f_011[i])*C1) / h0;
348                            const double V3=((f_111[i]-f_011[i])*C5 + (f_100[i]-f_000[i])*C0 + (f_101[i]+f_110[i]-f_001[i]-f_010[i])*C1) / h0;
349                            const double V4=((f_010[i]-f_000[i])*C5 + (f_111[i]-f_101[i])*C0 + (f_011[i]+f_110[i]-f_001[i]-f_100[i])*C1) / h1;
350                            const double V5=((f_110[i]-f_100[i])*C5 + (f_011[i]-f_001[i])*C0 + (f_010[i]+f_111[i]-f_000[i]-f_101[i])*C1) / h1;
351                            const double V6=((f_011[i]-f_001[i])*C5 + (f_110[i]-f_100[i])*C0 + (f_010[i]+f_111[i]-f_000[i]-f_101[i])*C1) / h1;
352                            const double V7=((f_111[i]-f_101[i])*C5 + (f_010[i]-f_000[i])*C0 + (f_011[i]+f_110[i]-f_001[i]-f_100[i])*C1) / h1;
353                            const double V8=((f_001[i]-f_000[i])*C5 + (f_111[i]-f_110[i])*C0 + (f_011[i]+f_101[i]-f_010[i]-f_100[i])*C1) / h2;
354                            const double V9=((f_101[i]-f_100[i])*C5 + (f_011[i]-f_010[i])*C0 + (f_001[i]+f_111[i]-f_000[i]-f_110[i])*C1) / h2;
355                            const double V10=((f_011[i]-f_010[i])*C5 + (f_101[i]-f_100[i])*C0 + (f_001[i]+f_111[i]-f_000[i]-f_110[i])*C1) / h2;
356                            const double V11=((f_111[i]-f_110[i])*C5 + (f_001[i]-f_000[i])*C0 + (f_011[i]+f_101[i]-f_010[i]-f_100[i])*C1) / h2;
357                            o[INDEX3(i,0,0,numComp,3)] = V0;
358                            o[INDEX3(i,1,0,numComp,3)] = V4;
359                            o[INDEX3(i,2,0,numComp,3)] = V8;
360                            o[INDEX3(i,0,1,numComp,3)] = V0;
361                            o[INDEX3(i,1,1,numComp,3)] = V5;
362                            o[INDEX3(i,2,1,numComp,3)] = V9;
363                            o[INDEX3(i,0,2,numComp,3)] = V1;
364                            o[INDEX3(i,1,2,numComp,3)] = V4;
365                            o[INDEX3(i,2,2,numComp,3)] = V10;
366                            o[INDEX3(i,0,3,numComp,3)] = V1;
367                            o[INDEX3(i,1,3,numComp,3)] = V5;
368                            o[INDEX3(i,2,3,numComp,3)] = V11;
369                            o[INDEX3(i,0,4,numComp,3)] = V2;
370                            o[INDEX3(i,1,4,numComp,3)] = V6;
371                            o[INDEX3(i,2,4,numComp,3)] = V8;
372                            o[INDEX3(i,0,5,numComp,3)] = V2;
373                            o[INDEX3(i,1,5,numComp,3)] = V7;
374                            o[INDEX3(i,2,5,numComp,3)] = V9;
375                            o[INDEX3(i,0,6,numComp,3)] = V3;
376                            o[INDEX3(i,1,6,numComp,3)] = V6;
377                            o[INDEX3(i,2,6,numComp,3)] = V10;
378                            o[INDEX3(i,0,7,numComp,3)] = V3;
379                            o[INDEX3(i,1,7,numComp,3)] = V7;
380                            o[INDEX3(i,2,7,numComp,3)] = V11;
381                        } /* end of component loop i */
382                    } /* end of k0 loop */
383                } /* end of k1 loop */
384            } /* end of k2 loop */
385            /* GENERATOR SNIP_GRAD_ELEMENTS BOTTOM */
386        } else if (out.getFunctionSpace().getTypeCode() == ReducedElements) {
387            /*** GENERATOR SNIP_GRAD_REDUCED_ELEMENTS TOP */
388    #pragma omp parallel for
389            for (index_t k2=0; k2 < m_NE2; ++k2) {
390                for (index_t k1=0; k1 < m_NE1; ++k1) {
391                    for (index_t k0=0; k0 < m_NE0; ++k0) {
392                        const register double* f_000 = in.getSampleDataRO(INDEX3(k0,k1,k2, m_N0,m_N1));
393                        const register double* f_001 = in.getSampleDataRO(INDEX3(k0,k1,k2+1, m_N0,m_N1));
394                        const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,k1,k2+1, m_N0,m_N1));
395                        const register double* f_011 = in.getSampleDataRO(INDEX3(k0,k1+1,k2+1, m_N0,m_N1));
396                        const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,k1,k2, m_N0,m_N1));
397                        const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,k1+1,k2, m_N0,m_N1));
398                        const register double* f_010 = in.getSampleDataRO(INDEX3(k0,k1+1,k2, m_N0,m_N1));
399                        const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,k1+1,k2+1, m_N0,m_N1));
400                        double* o = out.getSampleDataRW(INDEX3(k0,k1,k2,m_NE0,m_NE1));
401                        for (index_t i=0; i < numComp; ++i) {
402                            o[INDEX3(i,0,0,numComp,3)] = (f_100[i]+f_101[i]+f_110[i]+f_111[i]-f_000[i]-f_001[i]-f_010[i]-f_011[i])*C3 / h0;
403                            o[INDEX3(i,1,0,numComp,3)] = (f_010[i]+f_011[i]+f_110[i]+f_111[i]-f_000[i]-f_001[i]-f_100[i]-f_101[i])*C3 / h1;
404                            o[INDEX3(i,2,0,numComp,3)] = (f_001[i]+f_011[i]+f_101[i]+f_111[i]-f_000[i]-f_010[i]-f_100[i]-f_110[i])*C3 / h2;
405                        } /* end of component loop i */
406                    } /* end of k0 loop */
407                } /* end of k1 loop */
408            } /* end of k2 loop */
409            /* GENERATOR SNIP_GRAD_REDUCED_ELEMENTS BOTTOM */
410        } else if (out.getFunctionSpace().getTypeCode() == FaceElements) {
411            /*** GENERATOR SNIP_GRAD_FACES TOP */
412    #pragma omp parallel
413            {
414                if (m_faceOffset[0] > -1) {
415    #pragma omp for nowait
416                    for (index_t k2=0; k2 < m_NE2; ++k2) {
417                        for (index_t k1=0; k1 < m_NE1; ++k1) {
418                            const register double* f_000 = in.getSampleDataRO(INDEX3(0,k1,k2, m_N0,m_N1));
419                            const register double* f_001 = in.getSampleDataRO(INDEX3(0,k1,k2+1, m_N0,m_N1));
420                            const register double* f_101 = in.getSampleDataRO(INDEX3(1,k1,k2+1, m_N0,m_N1));
421                            const register double* f_111 = in.getSampleDataRO(INDEX3(1,k1+1,k2+1, m_N0,m_N1));
422                            const register double* f_110 = in.getSampleDataRO(INDEX3(1,k1+1,k2, m_N0,m_N1));
423                            const register double* f_011 = in.getSampleDataRO(INDEX3(0,k1+1,k2+1, m_N0,m_N1));
424                            const register double* f_010 = in.getSampleDataRO(INDEX3(0,k1+1,k2, m_N0,m_N1));
425                            const register double* f_100 = in.getSampleDataRO(INDEX3(1,k1,k2, m_N0,m_N1));
426                            double* o = out.getSampleDataRW(m_faceOffset[0]+INDEX2(k1,k2,m_NE1));
427                            for (index_t i=0; i < numComp; ++i) {
428                                const double V0=((f_010[i]-f_000[i])*C6 + (f_011[i]-f_001[i])*C2) / h1;
429                                const double V1=((f_010[i]-f_000[i])*C2 + (f_011[i]-f_001[i])*C6) / h1;
430                                const double V2=((f_001[i]-f_000[i])*C6 + (f_010[i]-f_011[i])*C2) / h2;
431                                const double V3=((f_001[i]-f_000[i])*C2 + (f_011[i]-f_010[i])*C6) / h2;
432                                o[INDEX3(i,0,0,numComp,3)] = ((f_100[i]-f_000[i])*C5 + (f_111[i]-f_011[i])*C0 + (f_101[i]+f_110[i]-f_001[i]-f_010[i])*C1) / h0;
433                                o[INDEX3(i,1,0,numComp,3)] = V0;
434                                o[INDEX3(i,2,0,numComp,3)] = V2;
435                                o[INDEX3(i,0,1,numComp,3)] = ((f_110[i]-f_010[i])*C5 + (f_101[i]-f_001[i])*C0 + (f_100[i]+f_111[i]-f_000[i]-f_011[i])*C1) / h0;
436                                o[INDEX3(i,1,1,numComp,3)] = V0;
437                                o[INDEX3(i,2,1,numComp,3)] = V3;
438                                o[INDEX3(i,0,2,numComp,3)] = ((f_101[i]-f_001[i])*C5 + (f_110[i]-f_010[i])*C0 + (f_100[i]+f_111[i]-f_000[i]-f_011[i])*C1) / h0;
439                                o[INDEX3(i,1,2,numComp,3)] = V1;
440                                o[INDEX3(i,2,2,numComp,3)] = V2;
441                                o[INDEX3(i,0,3,numComp,3)] = ((f_111[i]-f_011[i])*C5 + (f_100[i]-f_000[i])*C0 + (f_101[i]+f_110[i]-f_001[i]-f_010[i])*C1) / h0;
442                                o[INDEX3(i,1,3,numComp,3)] = V1;
443                                o[INDEX3(i,2,3,numComp,3)] = V3;
444                            } /* end of component loop i */
445                        } /* end of k1 loop */
446                    } /* end of k2 loop */
447                } /* end of face 0 */
448                if (m_faceOffset[1] > -1) {
449    #pragma omp for nowait
450                    for (index_t k2=0; k2 < m_NE2; ++k2) {
451                        for (index_t k1=0; k1 < m_NE1; ++k1) {
452                            const register double* f_000 = in.getSampleDataRO(INDEX3(m_N0-2,k1,k2, m_N0,m_N1));
453                            const register double* f_001 = in.getSampleDataRO(INDEX3(m_N0-2,k1,k2+1, m_N0,m_N1));
454                            const register double* f_101 = in.getSampleDataRO(INDEX3(m_N0-1,k1,k2+1, m_N0,m_N1));
455                            const register double* f_111 = in.getSampleDataRO(INDEX3(m_N0-1,k1+1,k2+1, m_N0,m_N1));
456                            const register double* f_110 = in.getSampleDataRO(INDEX3(m_N0-1,k1+1,k2, m_N0,m_N1));
457                            const register double* f_011 = in.getSampleDataRO(INDEX3(m_N0-2,k1+1,k2+1, m_N0,m_N1));
458                            const register double* f_010 = in.getSampleDataRO(INDEX3(m_N0-2,k1+1,k2, m_N0,m_N1));
459                            const register double* f_100 = in.getSampleDataRO(INDEX3(m_N0-1,k1,k2, m_N0,m_N1));
460                            double* o = out.getSampleDataRW(m_faceOffset[1]+INDEX2(k1,k2,m_NE1));
461                            for (index_t i=0; i < numComp; ++i) {
462                                const double V0=((f_110[i]-f_100[i])*C6 + (f_111[i]-f_101[i])*C2) / h1;
463                                const double V1=((f_110[i]-f_100[i])*C2 + (f_111[i]-f_101[i])*C6) / h1;
464                                const double V2=((f_101[i]-f_100[i])*C6 + (f_111[i]-f_110[i])*C2) / h2;
465                                const double V3=((f_101[i]-f_100[i])*C2 + (f_111[i]-f_110[i])*C6) / h2;
466                                o[INDEX3(i,0,0,numComp,3)] = ((f_100[i]-f_000[i])*C5 + (f_111[i]-f_011[i])*C0 + (f_101[i]+f_110[i]-f_001[i]-f_010[i])*C1) / h0;
467                                o[INDEX3(i,1,0,numComp,3)] = V0;
468                                o[INDEX3(i,2,0,numComp,3)] = V2;
469                                o[INDEX3(i,0,1,numComp,3)] = ((f_110[i]-f_010[i])*C5 + (f_101[i]-f_001[i])*C0 + (f_100[i]+f_111[i]-f_000[i]-f_011[i])*C1) / h0;
470                                o[INDEX3(i,1,1,numComp,3)] = V0;
471                                o[INDEX3(i,2,1,numComp,3)] = V3;
472                                o[INDEX3(i,0,2,numComp,3)] = ((f_101[i]-f_001[i])*C5 + (f_110[i]-f_010[i])*C0 + (f_100[i]+f_111[i]-f_000[i]-f_011[i])*C1) / h0;
473                                o[INDEX3(i,1,2,numComp,3)] = V1;
474                                o[INDEX3(i,2,2,numComp,3)] = V2;
475                                o[INDEX3(i,0,3,numComp,3)] = ((f_111[i]-f_011[i])*C5 + (f_100[i]-f_000[i])*C0 + (f_101[i]+f_110[i]-f_001[i]-f_010[i])*C1) / h0;
476                                o[INDEX3(i,1,3,numComp,3)] = V1;
477                                o[INDEX3(i,2,3,numComp,3)] = V3;
478                            } /* end of component loop i */
479                        } /* end of k1 loop */
480                    } /* end of k2 loop */
481                } /* end of face 1 */
482                if (m_faceOffset[2] > -1) {
483    #pragma omp for nowait
484                    for (index_t k2=0; k2 < m_NE2; ++k2) {
485                        for (index_t k0=0; k0 < m_NE0; ++k0) {
486                            const register double* f_000 = in.getSampleDataRO(INDEX3(k0,0,k2, m_N0,m_N1));
487                            const register double* f_001 = in.getSampleDataRO(INDEX3(k0,0,k2+1, m_N0,m_N1));
488                            const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,0,k2+1, m_N0,m_N1));
489                            const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,0,k2, m_N0,m_N1));
490                            const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,1,k2+1, m_N0,m_N1));
491                            const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,1,k2, m_N0,m_N1));
492                            const register double* f_011 = in.getSampleDataRO(INDEX3(k0,1,k2+1, m_N0,m_N1));
493                            const register double* f_010 = in.getSampleDataRO(INDEX3(k0,1,k2, m_N0,m_N1));
494                            double* o = out.getSampleDataRW(m_faceOffset[2]+INDEX2(k0,k2,m_NE0));
495                            for (index_t i=0; i < numComp; ++i) {
496                                const double V0=((f_100[i]-f_000[i])*C6 + (f_101[i]-f_001[i])*C2) / h0;
497                                const double V1=((f_001[i]-f_000[i])*C6 + (f_101[i]-f_100[i])*C2) / h2;
498                                const double V2=((f_001[i]-f_000[i])*C2 + (f_101[i]-f_100[i])*C6) / h2;
499                                o[INDEX3(i,0,0,numComp,3)] = V0;
500                                o[INDEX3(i,1,0,numComp,3)] = ((f_010[i]-f_000[i])*C5 + (f_111[i]-f_101[i])*C0 + (f_011[i]+f_110[i]-f_001[i]-f_100[i])*C1) / h1;
501                                o[INDEX3(i,2,0,numComp,3)] = V1;
502                                o[INDEX3(i,0,1,numComp,3)] = V0;
503                                o[INDEX3(i,1,1,numComp,3)] = ((f_110[i]-f_100[i])*C5 + (f_011[i]-f_001[i])*C0 + (f_010[i]+f_111[i]-f_000[i]-f_101[i])*C1) / h1;
504                                o[INDEX3(i,2,1,numComp,3)] = V2;
505                                o[INDEX3(i,0,2,numComp,3)] = V0;
506                                o[INDEX3(i,1,2,numComp,3)] = ((f_011[i]-f_001[i])*C5 + (f_110[i]-f_100[i])*C0 + (f_010[i]+f_111[i]-f_000[i]-f_101[i])*C1) / h1;
507                                o[INDEX3(i,2,2,numComp,3)] = V1;
508                                o[INDEX3(i,0,3,numComp,3)] = V0;
509                                o[INDEX3(i,1,3,numComp,3)] = ((f_111[i]-f_101[i])*C5 + (f_010[i]-f_000[i])*C0 + (f_011[i]+f_110[i]-f_001[i]-f_100[i])*C1) / h1;
510                                o[INDEX3(i,2,3,numComp,3)] = V2;
511                            } /* end of component loop i */
512                        } /* end of k0 loop */
513                    } /* end of k2 loop */
514                } /* end of face 2 */
515                if (m_faceOffset[3] > -1) {
516    #pragma omp for nowait
517                    for (index_t k2=0; k2 < m_NE2; ++k2) {
518                        for (index_t k0=0; k0 < m_NE0; ++k0) {
519                            const register double* f_011 = in.getSampleDataRO(INDEX3(k0,m_N1-1,k2+1, m_N0,m_N1));
520                            const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,m_N1-1,k2, m_N0,m_N1));
521                            const register double* f_010 = in.getSampleDataRO(INDEX3(k0,m_N1-1,k2, m_N0,m_N1));
522                            const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,m_N1-1,k2+1, m_N0,m_N1));
523                            const register double* f_000 = in.getSampleDataRO(INDEX3(k0,m_N1-2,k2, m_N0,m_N1));
524                            const register double* f_001 = in.getSampleDataRO(INDEX3(k0,m_N1-2,k2+1, m_N0,m_N1));
525                            const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,m_N1-2,k2+1, m_N0,m_N1));
526                            const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,m_N1-2,k2, m_N0,m_N1));
527                            double* o = out.getSampleDataRW(m_faceOffset[3]+INDEX2(k0,k2,m_NE0));
528                            for (index_t i=0; i < numComp; ++i) {
529                                const double V0=((f_110[i]-f_010[i])*C6 + (f_111[i]-f_011[i])*C2) / h0;
530                                const double V1=((f_110[i]-f_010[i])*C2 + (f_111[i]-f_011[i])*C6) / h0;
531                                const double V2=((f_011[i]-f_010[i])*C6 + (f_111[i]-f_110[i])*C2) / h2;
532                                const double V3=((f_011[i]-f_010[i])*C2 + (f_111[i]-f_110[i])*C6) / h2;
533                                o[INDEX3(i,0,0,numComp,3)] = V0;
534                                o[INDEX3(i,1,0,numComp,3)] = ((f_010[i]-f_000[i])*C5 + (f_111[i]-f_101[i])*C0 + (f_011[i]+f_110[i]-f_001[i]-f_100[i])*C1) / h1;
535                                o[INDEX3(i,2,0,numComp,3)] = V2;
536                                o[INDEX3(i,0,1,numComp,3)] = V0;
537                                o[INDEX3(i,1,1,numComp,3)] = ((f_110[i]-f_100[i])*C5 + (f_011[i]-f_001[i])*C0 + (f_010[i]+f_111[i]-f_000[i]-f_101[i])*C1) / h1;
538                                o[INDEX3(i,2,1,numComp,3)] = V3;
539                                o[INDEX3(i,0,2,numComp,3)] = V1;
540                                o[INDEX3(i,1,2,numComp,3)] = ((f_011[i]-f_001[i])*C5 + (f_110[i]-f_100[i])*C0 + (f_010[i]+f_111[i]-f_000[i]-f_101[i])*C1) / h1;
541                                o[INDEX3(i,2,2,numComp,3)] = V2;
542                                o[INDEX3(i,0,3,numComp,3)] = V1;
543                                o[INDEX3(i,1,3,numComp,3)] = ((f_111[i]-f_101[i])*C5 + (f_010[i]-f_000[i])*C0 + (f_011[i]+f_110[i]-f_001[i]-f_100[i])*C1) / h1;
544                                o[INDEX3(i,2,3,numComp,3)] = V3;
545                            } /* end of component loop i */
546                        } /* end of k0 loop */
547                    } /* end of k2 loop */
548                } /* end of face 3 */
549                if (m_faceOffset[4] > -1) {
550    #pragma omp for nowait
551                    for (index_t k1=0; k1 < m_NE1; ++k1) {
552                        for (index_t k0=0; k0 < m_NE0; ++k0) {
553                            const register double* f_000 = in.getSampleDataRO(INDEX3(k0,k1,0, m_N0,m_N1));
554                            const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,k1,0, m_N0,m_N1));
555                            const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,k1+1,0, m_N0,m_N1));
556                            const register double* f_010 = in.getSampleDataRO(INDEX3(k0,k1+1,0, m_N0,m_N1));
557                            const register double* f_001 = in.getSampleDataRO(INDEX3(k0,k1,1, m_N0,m_N1));
558                            const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,k1,1, m_N0,m_N1));
559                            const register double* f_011 = in.getSampleDataRO(INDEX3(k0,k1+1,1, m_N0,m_N1));
560                            const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,k1+1,1, m_N0,m_N1));
561                            double* o = out.getSampleDataRW(m_faceOffset[4]+INDEX2(k0,k1,m_NE0));
562                            for (index_t i=0; i < numComp; ++i) {
563                                const double V0=((f_100[i]-f_000[i])*C6 + (f_110[i]-f_010[i])*C2) / h0;
564                                const double V1=((f_100[i]-f_000[i])*C2 + (f_110[i]-f_010[i])*C6) / h0;
565                                const double V2=((f_010[i]-f_000[i])*C6 + (f_110[i]-f_100[i])*C2) / h1;
566                                const double V3=((f_010[i]-f_000[i])*C2 + (f_110[i]-f_100[i])*C6) / h1;
567                                o[INDEX3(i,0,0,numComp,3)] = V0;
568                                o[INDEX3(i,1,0,numComp,3)] = V2;
569                                o[INDEX3(i,2,0,numComp,3)] = ((f_001[i]-f_000[i])*C5 + (f_111[i]-f_110[i])*C0 + (f_011[i]+f_101[i]-f_010[i]-f_100[i])*C1) / h2;
570                                o[INDEX3(i,0,1,numComp,3)] = V0;
571                                o[INDEX3(i,1,1,numComp,3)] = V3;
572                                o[INDEX3(i,2,1,numComp,3)] = ((f_101[i]-f_100[i])*C5 + (f_011[i]-f_010[i])*C0 + (f_001[i]+f_111[i]-f_000[i]-f_110[i])*C1) / h2;
573                                o[INDEX3(i,0,2,numComp,3)] = V1;
574                                o[INDEX3(i,1,2,numComp,3)] = V2;
575                                o[INDEX3(i,2,2,numComp,3)] = ((f_011[i]-f_010[i])*C5 + (f_101[i]-f_100[i])*C0 + (f_001[i]+f_111[i]-f_000[i]-f_110[i])*C1) / h2;
576                                o[INDEX3(i,0,3,numComp,3)] = V1;
577                                o[INDEX3(i,1,3,numComp,3)] = V3;
578                                o[INDEX3(i,2,3,numComp,3)] = ((f_111[i]-f_110[i])*C5 + (f_001[i]-f_000[i])*C0 + (f_011[i]+f_101[i]-f_010[i]-f_100[i])*C1) / h2;
579                            } /* end of component loop i */
580                        } /* end of k0 loop */
581                    } /* end of k1 loop */
582                } /* end of face 4 */
583                if (m_faceOffset[5] > -1) {
584    #pragma omp for nowait
585                    for (index_t k1=0; k1 < m_NE1; ++k1) {
586                        for (index_t k0=0; k0 < m_NE0; ++k0) {
587                            const register double* f_001 = in.getSampleDataRO(INDEX3(k0,k1,m_N2-1, m_N0,m_N1));
588                            const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,k1,m_N2-1, m_N0,m_N1));
589                            const register double* f_011 = in.getSampleDataRO(INDEX3(k0,k1+1,m_N2-1, m_N0,m_N1));
590                            const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,k1+1,m_N2-1, m_N0,m_N1));
591                            const register double* f_000 = in.getSampleDataRO(INDEX3(k0,k1,m_N2-2, m_N0,m_N1));
592                            const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,k1+1,m_N2-2, m_N0,m_N1));
593                            const register double* f_010 = in.getSampleDataRO(INDEX3(k0,k1+1,m_N2-2, m_N0,m_N1));
594                            const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,k1,m_N2-2, m_N0,m_N1));
595                            double* o = out.getSampleDataRW(m_faceOffset[5]+INDEX2(k0,k1,m_NE0));
596                            for (index_t i=0; i < numComp; ++i) {
597                                const double V0=((f_101[i]-f_001[i])*C6 + (f_111[i]-f_011[i])*C2) / h0;
598                                const double V1=((f_101[i]-f_001[i])*C2 + (f_111[i]-f_011[i])*C6) / h0;
599                                const double V2=((f_011[i]-f_001[i])*C6 + (f_111[i]-f_101[i])*C2) / h1;
600                                const double V3=((f_011[i]-f_001[i])*C2 + (f_111[i]-f_101[i])*C6) / h1;
601                                o[INDEX3(i,0,0,numComp,3)] = V0;
602                                o[INDEX3(i,1,0,numComp,3)] = V2;
603                                o[INDEX3(i,2,0,numComp,3)] = ((f_001[i]-f_000[i])*C5 + (f_111[i]-f_110[i])*C0 + (f_011[i]+f_101[i]-f_010[i]-f_100[i])*C1) / h2;
604                                o[INDEX3(i,0,1,numComp,3)] = V0;
605                                o[INDEX3(i,1,1,numComp,3)] = V3;
606                                o[INDEX3(i,2,1,numComp,3)] = ((f_011[i]-f_010[i])*C0 + (f_101[i]-f_100[i])*C5 + (f_001[i]+f_111[i]-f_000[i]-f_110[i])*C1) / h2;
607                                o[INDEX3(i,0,2,numComp,3)] = V1;
608                                o[INDEX3(i,1,2,numComp,3)] = V2;
609                                o[INDEX3(i,2,2,numComp,3)] = ((f_011[i]-f_010[i])*C5 + (f_101[i]-f_100[i])*C0 + (f_001[i]+f_111[i]-f_000[i]-f_110[i])*C1) / h2;
610                                o[INDEX3(i,0,3,numComp,3)] = V1;
611                                o[INDEX3(i,1,3,numComp,3)] = V3;
612                                o[INDEX3(i,2,3,numComp,3)] = ((f_001[i]-f_000[i])*C0 + (f_111[i]-f_110[i])*C5 + (f_011[i]+f_101[i]-f_010[i]-f_100[i])*C1) / h2;
613                            } /* end of component loop i */
614                        } /* end of k0 loop */
615                    } /* end of k1 loop */
616                } /* end of face 5 */
617            } // end of parallel section
618            /* GENERATOR SNIP_GRAD_FACES BOTTOM */
619        } else if (out.getFunctionSpace().getTypeCode() == ReducedFaceElements) {
620            /*** GENERATOR SNIP_GRAD_REDUCED_FACES TOP */
621    #pragma omp parallel
622            {
623                if (m_faceOffset[0] > -1) {
624    #pragma omp for nowait
625                    for (index_t k2=0; k2 < m_NE2; ++k2) {
626                        for (index_t k1=0; k1 < m_NE1; ++k1) {
627                            const register double* f_000 = in.getSampleDataRO(INDEX3(0,k1,k2, m_N0,m_N1));
628                            const register double* f_001 = in.getSampleDataRO(INDEX3(0,k1,k2+1, m_N0,m_N1));
629                            const register double* f_101 = in.getSampleDataRO(INDEX3(1,k1,k2+1, m_N0,m_N1));
630                            const register double* f_011 = in.getSampleDataRO(INDEX3(0,k1+1,k2+1, m_N0,m_N1));
631                            const register double* f_100 = in.getSampleDataRO(INDEX3(1,k1,k2, m_N0,m_N1));
632                            const register double* f_110 = in.getSampleDataRO(INDEX3(1,k1+1,k2, m_N0,m_N1));
633                            const register double* f_010 = in.getSampleDataRO(INDEX3(0,k1+1,k2, m_N0,m_N1));
634                            const register double* f_111 = in.getSampleDataRO(INDEX3(1,k1+1,k2+1, m_N0,m_N1));
635                            double* o = out.getSampleDataRW(m_faceOffset[0]+INDEX2(k1,k2,m_NE1));
636                            for (index_t i=0; i < numComp; ++i) {
637                                o[INDEX3(i,0,0,numComp,3)] = (f_100[i]+f_101[i]+f_110[i]+f_111[i]-f_000[i]-f_001[i]-f_010[i]-f_011[i])*C3 / h0;
638                                o[INDEX3(i,1,0,numComp,3)] = (f_010[i]+f_011[i]-f_000[i]-f_001[i])*C4 / h1;
639                                o[INDEX3(i,2,0,numComp,3)] = (f_001[i]+f_011[i]-f_000[i]-f_010[i])*C4 / h2;
640                            } /* end of component loop i */
641                        } /* end of k1 loop */
642                    } /* end of k2 loop */
643                } /* end of face 0 */
644                if (m_faceOffset[1] > -1) {
645    #pragma omp for nowait
646                    for (index_t k2=0; k2 < m_NE2; ++k2) {
647                        for (index_t k1=0; k1 < m_NE1; ++k1) {
648                            const register double* f_000 = in.getSampleDataRO(INDEX3(m_N0-2,k1,k2, m_N0,m_N1));
649                            const register double* f_001 = in.getSampleDataRO(INDEX3(m_N0-2,k1,k2+1, m_N0,m_N1));
650                            const register double* f_101 = in.getSampleDataRO(INDEX3(m_N0-1,k1,k2+1, m_N0,m_N1));
651                            const register double* f_011 = in.getSampleDataRO(INDEX3(m_N0-2,k1+1,k2+1, m_N0,m_N1));
652                            const register double* f_100 = in.getSampleDataRO(INDEX3(m_N0-1,k1,k2, m_N0,m_N1));
653                            const register double* f_110 = in.getSampleDataRO(INDEX3(m_N0-1,k1+1,k2, m_N0,m_N1));
654                            const register double* f_010 = in.getSampleDataRO(INDEX3(m_N0-2,k1+1,k2, m_N0,m_N1));
655                            const register double* f_111 = in.getSampleDataRO(INDEX3(m_N0-1,k1+1,k2+1, m_N0,m_N1));
656                            double* o = out.getSampleDataRW(m_faceOffset[1]+INDEX2(k1,k2,m_NE1));
657                            for (index_t i=0; i < numComp; ++i) {
658                                o[INDEX3(i,0,0,numComp,3)] = (f_100[i]+f_101[i]+f_110[i]+f_111[i]-f_000[i]-f_001[i]-f_010[i]-f_011[i])*C3 / h0;
659                                o[INDEX3(i,1,0,numComp,3)] = (f_110[i]+f_111[i]-f_100[i]-f_101[i])*C4 / h1;
660                                o[INDEX3(i,2,0,numComp,3)] = (f_101[i]+f_111[i]-f_100[i]-f_110[i])*C4 / h2;
661                            } /* end of component loop i */
662                        } /* end of k1 loop */
663                    } /* end of k2 loop */
664                } /* end of face 1 */
665                if (m_faceOffset[2] > -1) {
666    #pragma omp for nowait
667                    for (index_t k2=0; k2 < m_NE2; ++k2) {
668                        for (index_t k0=0; k0 < m_NE0; ++k0) {
669                            const register double* f_000 = in.getSampleDataRO(INDEX3(k0,0,k2, m_N0,m_N1));
670                            const register double* f_001 = in.getSampleDataRO(INDEX3(k0,0,k2+1, m_N0,m_N1));
671                            const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,0,k2+1, m_N0,m_N1));
672                            const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,0,k2, m_N0,m_N1));
673                            const register double* f_011 = in.getSampleDataRO(INDEX3(k0,1,k2+1, m_N0,m_N1));
674                            const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,1,k2, m_N0,m_N1));
675                            const register double* f_010 = in.getSampleDataRO(INDEX3(k0,1,k2, m_N0,m_N1));
676                            const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,1,k2+1, m_N0,m_N1));
677                            double* o = out.getSampleDataRW(m_faceOffset[2]+INDEX2(k0,k2,m_NE0));
678                            for (index_t i=0; i < numComp; ++i) {
679                                o[INDEX3(i,0,0,numComp,3)] = (f_100[i]+f_101[i]-f_000[i]-f_001[i])*C4 / h0;
680                                o[INDEX3(i,1,0,numComp,3)] = (f_010[i]+f_011[i]+f_110[i]+f_111[i]-f_000[i]-f_001[i]-f_100[i]-f_101[i])*C3 / h1;
681                                o[INDEX3(i,2,0,numComp,3)] = (f_001[i]+f_101[i]-f_000[i]-f_100[i])*C4 / h2;
682                            } /* end of component loop i */
683                        } /* end of k0 loop */
684                    } /* end of k2 loop */
685                } /* end of face 2 */
686                if (m_faceOffset[3] > -1) {
687    #pragma omp for nowait
688                    for (index_t k2=0; k2 < m_NE2; ++k2) {
689                        for (index_t k0=0; k0 < m_NE0; ++k0) {
690                            const register double* f_011 = in.getSampleDataRO(INDEX3(k0,m_N1-1,k2+1, m_N0,m_N1));
691                            const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,m_N1-1,k2, m_N0,m_N1));
692                            const register double* f_010 = in.getSampleDataRO(INDEX3(k0,m_N1-1,k2, m_N0,m_N1));
693                            const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,m_N1-1,k2+1, m_N0,m_N1));
694                            const register double* f_000 = in.getSampleDataRO(INDEX3(k0,m_N1-2,k2, m_N0,m_N1));
695                            const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,m_N1-2,k2+1, m_N0,m_N1));
696                            const register double* f_001 = in.getSampleDataRO(INDEX3(k0,m_N1-2,k2+1, m_N0,m_N1));
697                            const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,m_N1-2,k2, m_N0,m_N1));
698                            double* o = out.getSampleDataRW(m_faceOffset[3]+INDEX2(k0,k2,m_NE0));
699                            for (index_t i=0; i < numComp; ++i) {
700                                o[INDEX3(i,0,0,numComp,3)] = (f_110[i]+f_111[i]-f_010[i]-f_011[i])*C4 / h0;
701                                o[INDEX3(i,1,0,numComp,3)] = (f_010[i]+f_011[i]+f_110[i]+f_111[i]-f_000[i]-f_001[i]-f_100[i]-f_101[i])*C3 / h1;
702                                o[INDEX3(i,2,0,numComp,3)] = (f_011[i]+f_111[i]-f_010[i]-f_110[i])*C4 / h2;
703                            } /* end of component loop i */
704                        } /* end of k0 loop */
705                    } /* end of k2 loop */
706                } /* end of face 3 */
707                if (m_faceOffset[4] > -1) {
708    #pragma omp for nowait
709                    for (index_t k1=0; k1 < m_NE1; ++k1) {
710                        for (index_t k0=0; k0 < m_NE0; ++k0) {
711                            const register double* f_000 = in.getSampleDataRO(INDEX3(k0,k1,0, m_N0,m_N1));
712                            const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,k1,0, m_N0,m_N1));
713                            const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,k1+1,0, m_N0,m_N1));
714                            const register double* f_010 = in.getSampleDataRO(INDEX3(k0,k1+1,0, m_N0,m_N1));
715                            const register double* f_001 = in.getSampleDataRO(INDEX3(k0,k1,1, m_N0,m_N1));
716                            const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,k1,1, m_N0,m_N1));
717                            const register double* f_011 = in.getSampleDataRO(INDEX3(k0,k1+1,1, m_N0,m_N1));
718                            const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,k1+1,1, m_N0,m_N1));
719                            double* o = out.getSampleDataRW(m_faceOffset[4]+INDEX2(k0,k1,m_NE0));
720                            for (index_t i=0; i < numComp; ++i) {
721                                o[INDEX3(i,0,0,numComp,3)] = (f_100[i]+f_110[i]-f_000[i]-f_010[i])*C4 / h0;
722                                o[INDEX3(i,1,0,numComp,3)] = (f_010[i]+f_110[i]-f_000[i]-f_100[i])*C4 / h1;
723                                o[INDEX3(i,2,0,numComp,3)] = (f_001[i]+f_011[i]+f_101[i]+f_111[i]-f_000[i]-f_010[i]-f_100[i]-f_110[i])*C4 / h2;
724                            } /* end of component loop i */
725                        } /* end of k0 loop */
726                    } /* end of k1 loop */
727                } /* end of face 4 */
728                if (m_faceOffset[5] > -1) {
729    #pragma omp for nowait
730                    for (index_t k1=0; k1 < m_NE1; ++k1) {
731                        for (index_t k0=0; k0 < m_NE0; ++k0) {
732                            const register double* f_001 = in.getSampleDataRO(INDEX3(k0,k1,m_N2-1, m_N0,m_N1));
733                            const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,k1,m_N2-1, m_N0,m_N1));
734                            const register double* f_011 = in.getSampleDataRO(INDEX3(k0,k1+1,m_N2-1, m_N0,m_N1));
735                            const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,k1+1,m_N2-1, m_N0,m_N1));
736                            const register double* f_000 = in.getSampleDataRO(INDEX3(k0,k1,m_N2-2, m_N0,m_N1));
737                            const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,k1,m_N2-2, m_N0,m_N1));
738                            const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,k1+1,m_N2-2, m_N0,m_N1));
739                            const register double* f_010 = in.getSampleDataRO(INDEX3(k0,k1+1,m_N2-2, m_N0,m_N1));
740                            double* o = out.getSampleDataRW(m_faceOffset[5]+INDEX2(k0,k1,m_NE0));
741                            for (index_t i=0; i < numComp; ++i) {
742                                o[INDEX3(i,0,0,numComp,3)] = (f_101[i]+f_111[i]-f_001[i]-f_011[i])*C4 / h0;
743                                o[INDEX3(i,1,0,numComp,3)] = (f_011[i]+f_111[i]-f_001[i]-f_101[i])*C4 / h1;
744                                o[INDEX3(i,2,0,numComp,3)] = (f_001[i]+f_011[i]+f_101[i]+f_111[i]-f_000[i]-f_010[i]-f_100[i]-f_110[i])*C3 / h2;
745                            } /* end of component loop i */
746                        } /* end of k0 loop */
747                    } /* end of k1 loop */
748                } /* end of face 5 */
749            } // end of parallel section
750            /* GENERATOR SNIP_GRAD_REDUCED_FACES BOTTOM */
751        } else {
752            stringstream msg;
753            msg << "setToGradient() not implemented for "
754                << functionSpaceTypeAsString(out.getFunctionSpace().getTypeCode());
755            throw RipleyException(msg.str());
756        }
757    }
758    
759    void Brick::setToIntegrals(vector<double>& integrals, const escript::Data& arg) const
760    {
761        escript::Data& in = *const_cast<escript::Data*>(&arg);
762        const dim_t numComp = in.getDataPointSize();
763        const double h0 = m_l0/m_gNE0;
764        const double h1 = m_l1/m_gNE1;
765        const double h2 = m_l2/m_gNE2;
766        if (arg.getFunctionSpace().getTypeCode() == Elements) {
767            const double w_0 = h0*h1*h2/8.;
768    #pragma omp parallel
769            {
770                vector<double> int_local(numComp, 0);
771    #pragma omp for nowait
772                for (index_t k2 = 0; k2 < m_NE2; ++k2) {
773                    for (index_t k1 = 0; k1 < m_NE1; ++k1) {
774                        for (index_t k0 = 0; k0 < m_NE0; ++k0) {
775                            const double* f = in.getSampleDataRO(INDEX3(k0, k1, k2, m_NE0, m_NE1));
776                            for (index_t i=0; i < numComp; ++i) {
777                                const register double f_0 = f[INDEX2(i,0,numComp)];
778                                const register double f_1 = f[INDEX2(i,1,numComp)];
779                                const register double f_2 = f[INDEX2(i,2,numComp)];
780                                const register double f_3 = f[INDEX2(i,3,numComp)];
781                                const register double f_4 = f[INDEX2(i,4,numComp)];
782                                const register double f_5 = f[INDEX2(i,5,numComp)];
783                                const register double f_6 = f[INDEX2(i,6,numComp)];
784                                const register double f_7 = f[INDEX2(i,7,numComp)];
785                                int_local[i]+=(f_0+f_1+f_2+f_3+f_4+f_5+f_6+f_7)*w_0;
786                            }  /* end of component loop i */
787                        } /* end of k0 loop */
788                    } /* end of k1 loop */
789                } /* end of k2 loop */
790    
791    #pragma omp critical
792                for (index_t i=0; i<numComp; i++)
793                    integrals[i]+=int_local[i];
794            } // end of parallel section
795        } else if (arg.getFunctionSpace().getTypeCode() == ReducedElements) {
796            const double w_0 = h0*h1*h2;
797    #pragma omp parallel
798            {
799                vector<double> int_local(numComp, 0);
800    #pragma omp for nowait
801                for (index_t k2 = 0; k2 < m_NE2; ++k2) {
802                    for (index_t k1 = 0; k1 < m_NE1; ++k1) {
803                        for (index_t k0 = 0; k0 < m_NE0; ++k0) {
804                            const double* f = in.getSampleDataRO(INDEX3(k0, k1, k2, m_NE0, m_NE1));
805                            for (index_t i=0; i < numComp; ++i) {
806                                int_local[i]+=f[i]*w_0;
807                            }  /* end of component loop i */
808                        } /* end of k0 loop */
809                    } /* end of k1 loop */
810                } /* end of k2 loop */
811    
812    #pragma omp critical
813                for (index_t i=0; i<numComp; i++)
814                    integrals[i]+=int_local[i];
815            } // end of parallel section
816        } else if (arg.getFunctionSpace().getTypeCode() == FaceElements) {
817            const double w_0 = h1*h2/4.;
818            const double w_1 = h0*h2/4.;
819            const double w_2 = h0*h1/4.;
820    #pragma omp parallel
821            {
822                vector<double> int_local(numComp, 0);
823                if (m_faceOffset[0] > -1) {
824    #pragma omp for nowait
825                    for (index_t k2=0; k2 < m_NE2; ++k2) {
826                        for (index_t k1=0; k1 < m_NE1; ++k1) {
827                            const double* f = in.getSampleDataRO(m_faceOffset[0]+INDEX2(k1,k2,m_NE1));
828                            for (index_t i=0; i < numComp; ++i) {
829                                const register double f_0 = f[INDEX2(i,0,numComp)];
830                                const register double f_1 = f[INDEX2(i,1,numComp)];
831                                const register double f_2 = f[INDEX2(i,2,numComp)];
832                                const register double f_3 = f[INDEX2(i,3,numComp)];
833                                int_local[i]+=(f_0+f_1+f_2+f_3)*w_0;
834                            }  /* end of component loop i */
835                        } /* end of k1 loop */
836                    } /* end of k2 loop */
837                }
838    
839                if (m_faceOffset[1] > -1) {
840    #pragma omp for nowait
841                    for (index_t k2=0; k2 < m_NE2; ++k2) {
842                        for (index_t k1=0; k1 < m_NE1; ++k1) {
843                            const double* f = in.getSampleDataRO(m_faceOffset[1]+INDEX2(k1,k2,m_NE1));
844                            for (index_t i=0; i < numComp; ++i) {
845                                const register double f_0 = f[INDEX2(i,0,numComp)];
846                                const register double f_1 = f[INDEX2(i,1,numComp)];
847                                const register double f_2 = f[INDEX2(i,2,numComp)];
848                                const register double f_3 = f[INDEX2(i,3,numComp)];
849                                int_local[i]+=(f_0+f_1+f_2+f_3)*w_0;
850                            }  /* end of component loop i */
851                        } /* end of k1 loop */
852                    } /* end of k2 loop */
853                }
854    
855                if (m_faceOffset[2] > -1) {
856    #pragma omp for nowait
857                    for (index_t k2=0; k2 < m_NE2; ++k2) {
858                        for (index_t k0=0; k0 < m_NE0; ++k0) {
859                            const double* f = in.getSampleDataRO(m_faceOffset[2]+INDEX2(k0,k2,m_NE0));
860                            for (index_t i=0; i < numComp; ++i) {
861                                const register double f_0 = f[INDEX2(i,0,numComp)];
862                                const register double f_1 = f[INDEX2(i,1,numComp)];
863                                const register double f_2 = f[INDEX2(i,2,numComp)];
864                                const register double f_3 = f[INDEX2(i,3,numComp)];
865                                int_local[i]+=(f_0+f_1+f_2+f_3)*w_1;
866                            }  /* end of component loop i */
867                        } /* end of k1 loop */
868                    } /* end of k2 loop */
869                }
870    
871                if (m_faceOffset[3] > -1) {
872    #pragma omp for nowait
873                    for (index_t k2=0; k2 < m_NE2; ++k2) {
874                        for (index_t k0=0; k0 < m_NE0; ++k0) {
875                            const double* f = in.getSampleDataRO(m_faceOffset[3]+INDEX2(k0,k2,m_NE0));
876                            for (index_t i=0; i < numComp; ++i) {
877                                const register double f_0 = f[INDEX2(i,0,numComp)];
878                                const register double f_1 = f[INDEX2(i,1,numComp)];
879                                const register double f_2 = f[INDEX2(i,2,numComp)];
880                                const register double f_3 = f[INDEX2(i,3,numComp)];
881                                int_local[i]+=(f_0+f_1+f_2+f_3)*w_1;
882                            }  /* end of component loop i */
883                        } /* end of k1 loop */
884                    } /* end of k2 loop */
885                }
886    
887                if (m_faceOffset[4] > -1) {
888    #pragma omp for nowait
889                    for (index_t k1=0; k1 < m_NE1; ++k1) {
890                        for (index_t k0=0; k0 < m_NE0; ++k0) {
891                            const double* f = in.getSampleDataRO(m_faceOffset[4]+INDEX2(k0,k1,m_NE0));
892                            for (index_t i=0; i < numComp; ++i) {
893                                const register double f_0 = f[INDEX2(i,0,numComp)];
894                                const register double f_1 = f[INDEX2(i,1,numComp)];
895                                const register double f_2 = f[INDEX2(i,2,numComp)];
896                                const register double f_3 = f[INDEX2(i,3,numComp)];
897                                int_local[i]+=(f_0+f_1+f_2+f_3)*w_2;
898                            }  /* end of component loop i */
899                        } /* end of k1 loop */
900                    } /* end of k2 loop */
901                }
902    
903                if (m_faceOffset[5] > -1) {
904    #pragma omp for nowait
905                    for (index_t k1=0; k1 < m_NE1; ++k1) {
906                        for (index_t k0=0; k0 < m_NE0; ++k0) {
907                            const double* f = in.getSampleDataRO(m_faceOffset[5]+INDEX2(k0,k1,m_NE0));
908                            for (index_t i=0; i < numComp; ++i) {
909                                const register double f_0 = f[INDEX2(i,0,numComp)];
910                                const register double f_1 = f[INDEX2(i,1,numComp)];
911                                const register double f_2 = f[INDEX2(i,2,numComp)];
912                                const register double f_3 = f[INDEX2(i,3,numComp)];
913                                int_local[i]+=(f_0+f_1+f_2+f_3)*w_2;
914                            }  /* end of component loop i */
915                        } /* end of k1 loop */
916                    } /* end of k2 loop */
917                }
918    
919    #pragma omp critical
920                for (index_t i=0; i<numComp; i++)
921                    integrals[i]+=int_local[i];
922            } // end of parallel section
923    
924        } else if (arg.getFunctionSpace().getTypeCode() == ReducedFaceElements) {
925            const double w_0 = h1*h2;
926            const double w_1 = h0*h2;
927            const double w_2 = h0*h1;
928    #pragma omp parallel
929            {
930                vector<double> int_local(numComp, 0);
931                if (m_faceOffset[0] > -1) {
932    #pragma omp for nowait
933                    for (index_t k2=0; k2 < m_NE2; ++k2) {
934                        for (index_t k1=0; k1 < m_NE1; ++k1) {
935                            const double* f = in.getSampleDataRO(m_faceOffset[0]+INDEX2(k1,k2,m_NE1));
936                            for (index_t i=0; i < numComp; ++i) {
937                                int_local[i]+=f[i]*w_0;
938                            }  /* end of component loop i */
939                        } /* end of k1 loop */
940                    } /* end of k2 loop */
941                }
942    
943                if (m_faceOffset[1] > -1) {
944    #pragma omp for nowait
945                    for (index_t k2=0; k2 < m_NE2; ++k2) {
946                        for (index_t k1=0; k1 < m_NE1; ++k1) {
947                            const double* f = in.getSampleDataRO(m_faceOffset[1]+INDEX2(k1,k2,m_NE1));
948                            for (index_t i=0; i < numComp; ++i) {
949                                int_local[i]+=f[i]*w_0;
950                            }  /* end of component loop i */
951                        } /* end of k1 loop */
952                    } /* end of k2 loop */
953                }
954    
955                if (m_faceOffset[2] > -1) {
956    #pragma omp for nowait
957                    for (index_t k2=0; k2 < m_NE2; ++k2) {
958                        for (index_t k0=0; k0 < m_NE0; ++k0) {
959                            const double* f = in.getSampleDataRO(m_faceOffset[2]+INDEX2(k0,k2,m_NE0));
960                            for (index_t i=0; i < numComp; ++i) {
961                                int_local[i]+=f[i]*w_1;
962                            }  /* end of component loop i */
963                        } /* end of k1 loop */
964                    } /* end of k2 loop */
965                }
966    
967                if (m_faceOffset[3] > -1) {
968    #pragma omp for nowait
969                    for (index_t k2=0; k2 < m_NE2; ++k2) {
970                        for (index_t k0=0; k0 < m_NE0; ++k0) {
971                            const double* f = in.getSampleDataRO(m_faceOffset[3]+INDEX2(k0,k2,m_NE0));
972                            for (index_t i=0; i < numComp; ++i) {
973                                int_local[i]+=f[i]*w_1;
974                            }  /* end of component loop i */
975                        } /* end of k1 loop */
976                    } /* end of k2 loop */
977                }
978    
979                if (m_faceOffset[4] > -1) {
980    #pragma omp for nowait
981                    for (index_t k1=0; k1 < m_NE1; ++k1) {
982                        for (index_t k0=0; k0 < m_NE0; ++k0) {
983                            const double* f = in.getSampleDataRO(m_faceOffset[4]+INDEX2(k0,k1,m_NE0));
984                            for (index_t i=0; i < numComp; ++i) {
985                                int_local[i]+=f[i]*w_2;
986                            }  /* end of component loop i */
987                        } /* end of k1 loop */
988                    } /* end of k2 loop */
989                }
990    
991                if (m_faceOffset[5] > -1) {
992    #pragma omp for nowait
993                    for (index_t k1=0; k1 < m_NE1; ++k1) {
994                        for (index_t k0=0; k0 < m_NE0; ++k0) {
995                            const double* f = in.getSampleDataRO(m_faceOffset[5]+INDEX2(k0,k1,m_NE0));
996                            for (index_t i=0; i < numComp; ++i) {
997                                int_local[i]+=f[i]*w_2;
998                            }  /* end of component loop i */
999                        } /* end of k1 loop */
1000                    } /* end of k2 loop */
1001                }
1002    
1003    #pragma omp critical
1004                for (index_t i=0; i<numComp; i++)
1005                    integrals[i]+=int_local[i];
1006            } // end of parallel section
1007    
1008        } else {
1009            stringstream msg;
1010            msg << "setToIntegrals() not implemented for "
1011                << functionSpaceTypeAsString(arg.getFunctionSpace().getTypeCode());
1012            throw RipleyException(msg.str());
1013        }
1014    }
1015    
1016    void Brick::setToNormal(escript::Data& out) const
1017    {
1018        if (out.getFunctionSpace().getTypeCode() == FaceElements) {
1019    #pragma omp parallel
1020            {
1021                if (m_faceOffset[0] > -1) {
1022    #pragma omp for nowait
1023                    for (index_t k2 = 0; k2 < m_NE2; ++k2) {
1024                        for (index_t k1 = 0; k1 < m_NE1; ++k1) {
1025                            double* o = out.getSampleDataRW(m_faceOffset[0]+INDEX2(k1,k2,m_NE1));
1026                            // set vector at four quadrature points
1027                            *o++ = -1.; *o++ = 0.; *o++ = 0.;
1028                            *o++ = -1.; *o++ = 0.; *o++ = 0.;
1029                            *o++ = -1.; *o++ = 0.; *o++ = 0.;
1030                            *o++ = -1.; *o++ = 0.; *o = 0.;
1031                        }
1032                    }
1033                }
1034    
1035                if (m_faceOffset[1] > -1) {
1036    #pragma omp for nowait
1037                    for (index_t k2 = 0; k2 < m_NE2; ++k2) {
1038                        for (index_t k1 = 0; k1 < m_NE1; ++k1) {
1039                            double* o = out.getSampleDataRW(m_faceOffset[1]+INDEX2(k1,k2,m_NE1));
1040                            // set vector at four quadrature points
1041                            *o++ = 1.; *o++ = 0.; *o++ = 0.;
1042                            *o++ = 1.; *o++ = 0.; *o++ = 0.;
1043                            *o++ = 1.; *o++ = 0.; *o++ = 0.;
1044                            *o++ = 1.; *o++ = 0.; *o = 0.;
1045                        }
1046                    }
1047                }
1048    
1049                if (m_faceOffset[2] > -1) {
1050    #pragma omp for nowait
1051                    for (index_t k2 = 0; k2 < m_NE2; ++k2) {
1052                        for (index_t k0 = 0; k0 < m_NE0; ++k0) {
1053                            double* o = out.getSampleDataRW(m_faceOffset[2]+INDEX2(k0,k2,m_NE0));
1054                            // set vector at four quadrature points
1055                            *o++ = 0.; *o++ = -1.; *o++ = 0.;
1056                            *o++ = 0.; *o++ = -1.; *o++ = 0.;
1057                            *o++ = 0.; *o++ = -1.; *o++ = 0.;
1058                            *o++ = 0.; *o++ = -1.; *o = 0.;
1059                        }
1060                    }
1061                }
1062    
1063                if (m_faceOffset[3] > -1) {
1064    #pragma omp for nowait
1065                    for (index_t k2 = 0; k2 < m_NE2; ++k2) {
1066                        for (index_t k0 = 0; k0 < m_NE0; ++k0) {
1067                            double* o = out.getSampleDataRW(m_faceOffset[3]+INDEX2(k0,k2,m_NE0));
1068                            // set vector at four quadrature points
1069                            *o++ = 0.; *o++ = 1.; *o++ = 0.;
1070                            *o++ = 0.; *o++ = 1.; *o++ = 0.;
1071                            *o++ = 0.; *o++ = 1.; *o++ = 0.;
1072                            *o++ = 0.; *o++ = 1.; *o = 0.;
1073                        }
1074                    }
1075                }
1076    
1077                if (m_faceOffset[4] > -1) {
1078    #pragma omp for nowait
1079                    for (index_t k1 = 0; k1 < m_NE1; ++k1) {
1080                        for (index_t k0 = 0; k0 < m_NE0; ++k0) {
1081                            double* o = out.getSampleDataRW(m_faceOffset[4]+INDEX2(k0,k1,m_NE0));
1082                            // set vector at four quadrature points
1083                            *o++ = 0.; *o++ = 0.; *o++ = -1.;
1084                            *o++ = 0.; *o++ = 0.; *o++ = -1.;
1085                            *o++ = 0.; *o++ = 0.; *o++ = -1.;
1086                            *o++ = 0.; *o++ = 0.; *o = -1.;
1087                        }
1088                    }
1089                }
1090    
1091                if (m_faceOffset[5] > -1) {
1092    #pragma omp for nowait
1093                    for (index_t k1 = 0; k1 < m_NE1; ++k1) {
1094                        for (index_t k0 = 0; k0 < m_NE0; ++k0) {
1095                            double* o = out.getSampleDataRW(m_faceOffset[5]+INDEX2(k0,k1,m_NE0));
1096                            // set vector at four quadrature points
1097                            *o++ = 0.; *o++ = 0.; *o++ = 1.;
1098                            *o++ = 0.; *o++ = 0.; *o++ = 1.;
1099                            *o++ = 0.; *o++ = 0.; *o++ = 1.;
1100                            *o++ = 0.; *o++ = 0.; *o = 1.;
1101                        }
1102                    }
1103                }
1104            } // end of parallel section
1105        } else if (out.getFunctionSpace().getTypeCode() == ReducedFaceElements) {
1106    #pragma omp parallel
1107            {
1108                if (m_faceOffset[0] > -1) {
1109    #pragma omp for nowait
1110                    for (index_t k2 = 0; k2 < m_NE2; ++k2) {
1111                        for (index_t k1 = 0; k1 < m_NE1; ++k1) {
1112                            double* o = out.getSampleDataRW(m_faceOffset[0]+INDEX2(k1,k2,m_NE1));
1113                            *o++ = -1.;
1114                            *o++ = 0.;
1115                            *o = 0.;
1116                        }
1117                    }
1118                }
1119    
1120                if (m_faceOffset[1] > -1) {
1121    #pragma omp for nowait
1122                    for (index_t k2 = 0; k2 < m_NE2; ++k2) {
1123                        for (index_t k1 = 0; k1 < m_NE1; ++k1) {
1124                            double* o = out.getSampleDataRW(m_faceOffset[1]+INDEX2(k1,k2,m_NE1));
1125                            *o++ = 1.;
1126                            *o++ = 0.;
1127                            *o = 0.;
1128                        }
1129                    }
1130                }
1131    
1132                if (m_faceOffset[2] > -1) {
1133    #pragma omp for nowait
1134                    for (index_t k2 = 0; k2 < m_NE2; ++k2) {
1135                        for (index_t k0 = 0; k0 < m_NE0; ++k0) {
1136                            double* o = out.getSampleDataRW(m_faceOffset[2]+INDEX2(k0,k2,m_NE0));
1137                            *o++ = 0.;
1138                            *o++ = -1.;
1139                            *o = 0.;
1140                        }
1141                    }
1142                }
1143    
1144                if (m_faceOffset[3] > -1) {
1145    #pragma omp for nowait
1146                    for (index_t k2 = 0; k2 < m_NE2; ++k2) {
1147                        for (index_t k0 = 0; k0 < m_NE0; ++k0) {
1148                            double* o = out.getSampleDataRW(m_faceOffset[3]+INDEX2(k0,k2,m_NE0));
1149                            *o++ = 0.;
1150                            *o++ = 1.;
1151                            *o = 0.;
1152                        }
1153                    }
1154                }
1155    
1156                if (m_faceOffset[4] > -1) {
1157    #pragma omp for nowait
1158                    for (index_t k1 = 0; k1 < m_NE1; ++k1) {
1159                        for (index_t k0 = 0; k0 < m_NE0; ++k0) {
1160                            double* o = out.getSampleDataRW(m_faceOffset[4]+INDEX2(k0,k1,m_NE0));
1161                            *o++ = 0.;
1162                            *o++ = 0.;
1163                            *o = -1.;
1164                        }
1165                    }
1166                }
1167    
1168                if (m_faceOffset[5] > -1) {
1169    #pragma omp for nowait
1170                    for (index_t k1 = 0; k1 < m_NE1; ++k1) {
1171                        for (index_t k0 = 0; k0 < m_NE0; ++k0) {
1172                            double* o = out.getSampleDataRW(m_faceOffset[5]+INDEX2(k0,k1,m_NE0));
1173                            *o++ = 0.;
1174                            *o++ = 0.;
1175                            *o = 1.;
1176                        }
1177                    }
1178                }
1179            } // end of parallel section
1180    
1181        } else {
1182            stringstream msg;
1183            msg << "setToNormal() not implemented for "
1184                << functionSpaceTypeAsString(out.getFunctionSpace().getTypeCode());
1185            throw RipleyException(msg.str());
1186        }
1187    }
1188    
1189  Paso_SystemMatrixPattern* Brick::getPattern(bool reducedRowOrder,  Paso_SystemMatrixPattern* Brick::getPattern(bool reducedRowOrder,
1190                                              bool reducedColOrder) const                                              bool reducedColOrder) const
1191  {  {
1192      if (reducedRowOrder || reducedColOrder)      if (reducedRowOrder || reducedColOrder)
1193          throw RipleyException("getPattern() not implemented for reduced order");          throw RipleyException("getPattern() not implemented for reduced order");
1194    
1195      throw RipleyException("getPattern() not implemented");      return m_pattern;
1196  }  }
1197    
1198  void Brick::Print_Mesh_Info(const bool full) const  void Brick::Print_Mesh_Info(const bool full) const
# Line 343  pair<double,double> Brick::getFirstCoord Line 1268  pair<double,double> Brick::getFirstCoord
1268      throw RipleyException("getFirstCoordAndSpacing(): invalid argument");      throw RipleyException("getFirstCoordAndSpacing(): invalid argument");
1269  }  }
1270    
1271    //protected
1272    dim_t Brick::getNumDOF() const
1273    {
1274        return (m_gNE0+1)/m_NX*(m_gNE1+1)/m_NY*(m_gNE2+1)/m_NZ;
1275    }
1276    
1277  //protected  //protected
1278  dim_t Brick::getNumFaceElements() const  dim_t Brick::getNumFaceElements() const
1279  {  {
1280        const IndexVector faces = getNumFacesPerBoundary();
1281      dim_t n=0;      dim_t n=0;
1282      //left      for (size_t i=0; i<faces.size(); i++)
1283      if (m_offset0==0)          n+=faces[i];
         n+=m_NE1*m_NE2;  
     //right  
     if (m_mpiInfo->rank%m_NX==m_NX-1)  
         n+=m_NE1*m_NE2;  
     //bottom  
     if (m_offset1==0)  
         n+=m_NE0*m_NE2;  
     //top  
     if (m_mpiInfo->rank%(m_NX*m_NY)/m_NX==m_NY-1)  
         n+=m_NE0*m_NE2;  
     //front  
     if (m_offset2==0)  
         n+=m_NE0*m_NE1;  
     //back  
     if (m_mpiInfo->rank/(m_NX*m_NY)==m_NZ-1)  
         n+=m_NE0*m_NE1;  
   
1284      return n;      return n;
1285  }  }
1286    
# Line 397  void Brick::assembleCoordinates(escript: Line 1311  void Brick::assembleCoordinates(escript:
1311      }      }
1312  }  }
1313    
1314    //protected
1315    dim_t Brick::insertNeighbourNodes(IndexVector& index, index_t node) const
1316    {
1317        const dim_t nDOF0 = (m_gNE0+1)/m_NX;
1318        const dim_t nDOF1 = (m_gNE1+1)/m_NY;
1319        const dim_t nDOF2 = (m_gNE2+1)/m_NZ;
1320        const int x=node%nDOF0;
1321        const int y=node%(nDOF0*nDOF1)/nDOF0;
1322        const int z=node/(nDOF0*nDOF1);
1323        int num=0;
1324        // loop through potential neighbours and add to index if positions are
1325        // within bounds
1326        for (int i2=-1; i2<2; i2++) {
1327            for (int i1=-1; i1<2; i1++) {
1328                for (int i0=-1; i0<2; i0++) {
1329                    // skip node itself
1330                    if (i0==0 && i1==0 && i2==0)
1331                        continue;
1332                    // location of neighbour node
1333                    const int nx=x+i0;
1334                    const int ny=y+i1;
1335                    const int nz=z+i2;
1336                    if (nx>=0 && ny>=0 && nz>=0
1337                            && nx<nDOF0 && ny<nDOF1 && nz<nDOF2) {
1338                        index.push_back(nz*nDOF0*nDOF1+ny*nDOF0+nx);
1339                        num++;
1340                    }
1341                }
1342            }
1343        }
1344    
1345        return num;
1346    }
1347    
1348    //protected
1349    void Brick::nodesToDOF(escript::Data& out, escript::Data& in) const
1350    {
1351        const dim_t numComp = in.getDataPointSize();
1352        out.requireWrite();
1353    
1354        const index_t left = (m_offset0==0 ? 0 : 1);
1355        const index_t bottom = (m_offset1==0 ? 0 : 1);
1356        const index_t front = (m_offset2==0 ? 0 : 1);
1357        const dim_t nDOF0 = (m_gNE0+1)/m_NX;
1358        const dim_t nDOF1 = (m_gNE1+1)/m_NY;
1359        const dim_t nDOF2 = (m_gNE2+1)/m_NZ;
1360    #pragma omp parallel for
1361        for (index_t i=0; i<nDOF2; i++) {
1362            for (index_t j=0; j<nDOF1; j++) {
1363                for (index_t k=0; k<nDOF0; k++) {
1364                    const index_t n=k+left+(j+bottom)*m_N0+(i+front)*m_N0*m_N1;
1365                    const double* src=in.getSampleDataRO(n);
1366                    copy(src, src+numComp, out.getSampleDataRW(k+j*nDOF0+i*nDOF0*nDOF1));
1367                }
1368            }
1369        }
1370    }
1371    
1372    //protected
1373    void Brick::dofToNodes(escript::Data& out, escript::Data& in) const
1374    {
1375        const dim_t numComp = in.getDataPointSize();
1376        Paso_Coupler* coupler = Paso_Coupler_alloc(m_connector, numComp);
1377        in.requireWrite();
1378        Paso_Coupler_startCollect(coupler, in.getSampleDataRW(0));
1379    
1380        const dim_t numDOF = getNumDOF();
1381        out.requireWrite();
1382        const double* buffer = Paso_Coupler_finishCollect(coupler);
1383    
1384    #pragma omp parallel for
1385        for (index_t i=0; i<getNumNodes(); i++) {
1386            const double* src=(m_dofMap[i]<numDOF ?
1387                    in.getSampleDataRO(m_dofMap[i])
1388                    : &buffer[(m_dofMap[i]-numDOF)*numComp]);
1389            copy(src, src+numComp, out.getSampleDataRW(i));
1390        }
1391    }
1392    
1393  //private  //private
1394  void Brick::populateSampleIds()  void Brick::populateSampleIds()
1395  {  {
1396      // identifiers are ordered from left to right, bottom to top, front to back      // identifiers are ordered from left to right, bottom to top, front to back
1397      // on each rank, except for the shared nodes which are owned by the rank      // globally
     // below / to the left / to the front of the current rank  
1398    
1399      // build node distribution vector first.      // build node distribution vector first.
     // m_nodeDistribution[i] is the first node id on rank i, that is  
1400      // rank i owns m_nodeDistribution[i+1]-nodeDistribution[i] nodes      // rank i owns m_nodeDistribution[i+1]-nodeDistribution[i] nodes
1401      m_nodeDistribution.assign(m_mpiInfo->size+1, 0);      m_nodeDistribution.assign(m_mpiInfo->size+1, 0);
1402      m_nodeDistribution[1]=getNumNodes();      const dim_t numDOF=getNumDOF();
1403      for (dim_t k=1; k<m_mpiInfo->size-1; k++) {      for (dim_t k=1; k<m_mpiInfo->size; k++) {
1404          const index_t x = k%m_NX;          m_nodeDistribution[k]=k*numDOF;
         const index_t y = k%(m_NX*m_NY)/m_NX;  
         const index_t z = k/(m_NX*m_NY);  
         index_t numNodes=getNumNodes();  
         if (x>0)  
             numNodes-=m_N1*m_N2;  
         if (y>0)  
             numNodes-=m_N0*m_N2;  
         if (z>0)  
             numNodes-=m_N0*m_N1;  
         // if an edge was subtracted twice add it back  
         if (x>0 && y>0)  
             numNodes+=m_N2;  
         if (x>0 && z>0)  
             numNodes+=m_N1;  
         if (y>0 && z>0)  
             numNodes+=m_N0;  
         // the corner node was removed 3x and added back 3x, so subtract it  
         if (x>0 && y>0 && z>0)  
             numNodes--;  
         m_nodeDistribution[k+1]=m_nodeDistribution[k]+numNodes;  
1405      }      }
1406      m_nodeDistribution[m_mpiInfo->size]=getNumDataPointsGlobal();      m_nodeDistribution[m_mpiInfo->size]=getNumDataPointsGlobal();
   
1407      m_nodeId.resize(getNumNodes());      m_nodeId.resize(getNumNodes());
1408        m_dofId.resize(numDOF);
1409        m_elementId.resize(getNumElements());
1410        m_faceId.resize(getNumFaceElements());
1411    
1412    #pragma omp parallel
1413        {
1414    #pragma omp for nowait
1415            // nodes
1416            for (dim_t i2=0; i2<m_N2; i2++) {
1417                for (dim_t i1=0; i1<m_N1; i1++) {
1418                    for (dim_t i0=0; i0<m_N0; i0++) {
1419                        m_nodeId[i0+i1*m_N0+i2*m_N0*m_N1] =
1420                            (m_offset2+i2)*(m_gNE0+1)*(m_gNE1+1)
1421                            +(m_offset1+i1)*(m_gNE0+1)
1422                            +m_offset0+i0;
1423                    }
1424                }
1425            }
1426    
1427            // degrees of freedom
1428    #pragma omp for nowait
1429            for (dim_t k=0; k<numDOF; k++)
1430                m_dofId[k] = m_nodeDistribution[m_mpiInfo->rank]+k;
1431    
1432            // elements
1433    #pragma omp for nowait
1434            for (dim_t i2=0; i2<m_NE2; i2++) {
1435                for (dim_t i1=0; i1<m_NE1; i1++) {
1436                    for (dim_t i0=0; i0<m_NE0; i0++) {
1437                        m_elementId[i0+i1*m_NE0+i2*m_NE0*m_NE1] =
1438                            (m_offset2+i2)*m_gNE0*m_gNE1
1439                            +(m_offset1+i1)*m_gNE0
1440                            +m_offset0+i0;
1441                    }
1442                }
1443            }
1444    
1445            // face elements
1446    #pragma omp for
1447            for (dim_t k=0; k<getNumFaceElements(); k++)
1448                m_faceId[k]=k;
1449        } // end parallel section
1450    
1451        m_nodeTags.assign(getNumNodes(), 0);
1452        updateTagsInUse(Nodes);
1453    
1454        m_elementTags.assign(getNumElements(), 0);
1455        updateTagsInUse(Elements);
1456    
1457        // generate face offset vector and set face tags
1458        const IndexVector facesPerEdge = getNumFacesPerBoundary();
1459        const index_t LEFT=1, RIGHT=2, BOTTOM=10, TOP=20, FRONT=100, BACK=200;
1460        const index_t faceTag[] = { LEFT, RIGHT, BOTTOM, TOP, FRONT, BACK };
1461        m_faceOffset.assign(facesPerEdge.size(), -1);
1462        m_faceTags.clear();
1463        index_t offset=0;
1464        for (size_t i=0; i<facesPerEdge.size(); i++) {
1465            if (facesPerEdge[i]>0) {
1466                m_faceOffset[i]=offset;
1467                offset+=facesPerEdge[i];
1468                m_faceTags.insert(m_faceTags.end(), facesPerEdge[i], faceTag[i]);
1469            }
1470        }
1471        setTagMap("left", LEFT);
1472        setTagMap("right", RIGHT);
1473        setTagMap("bottom", BOTTOM);
1474        setTagMap("top", TOP);
1475        setTagMap("front", FRONT);
1476        setTagMap("back", BACK);
1477        updateTagsInUse(FaceElements);
1478    }
1479    
1480      // the bottom, left and front planes are not owned by this rank so the  //private
1481      // identifiers need to be computed accordingly  void Brick::createPattern()
1482    {
1483        const dim_t nDOF0 = (m_gNE0+1)/m_NX;
1484        const dim_t nDOF1 = (m_gNE1+1)/m_NY;
1485        const dim_t nDOF2 = (m_gNE2+1)/m_NZ;
1486      const index_t left = (m_offset0==0 ? 0 : 1);      const index_t left = (m_offset0==0 ? 0 : 1);
1487      const index_t bottom = (m_offset1==0 ? 0 : 1);      const index_t bottom = (m_offset1==0 ? 0 : 1);
1488      const index_t front = (m_offset2==0 ? 0 : 1);      const index_t front = (m_offset2==0 ? 0 : 1);
1489    
1490      // case 1: all nodes on left plane are owned by rank on the left      // populate node->DOF mapping with own degrees of freedom.
1491      if (left>0) {      // The rest is assigned in the loop further down
1492          const int neighbour=m_mpiInfo->rank-1;      m_dofMap.assign(getNumNodes(), 0);
         const index_t leftN0=(neighbour%m_NX == 0 ? m_N0 : m_N0-1);  
         const index_t leftN1=(neighbour%(m_NX*m_NY)/m_NX==0 ? m_N1 : m_N1-1);  
1493  #pragma omp parallel for  #pragma omp parallel for
1494          for (dim_t i2=front; i2<m_N2; i2++) {      for (index_t i=front; i<m_N2; i++) {
1495              for (dim_t i1=bottom; i1<m_N1; i1++) {          for (index_t j=bottom; j<m_N1; j++) {
1496                  m_nodeId[i1*m_N0+i2*m_N0*m_N1]=m_nodeDistribution[neighbour]              for (index_t k=left; k<m_N0; k++) {
1497                      + (i1-bottom+1)*leftN0                  m_dofMap[i*m_N0*m_N1+j*m_N0+k]=(i-front)*nDOF0*nDOF1+(j-bottom)*nDOF0+k-left;
                     + (i2-front)*leftN0*leftN1 - 1;  
1498              }              }
1499          }          }
1500      }      }
1501      // case 2: all nodes on bottom plane are owned by rank below  
1502      if (bottom>0) {      // build list of shared components and neighbours by looping through
1503          const int neighbour=m_mpiInfo->rank-m_NX;      // all potential neighbouring ranks and checking if positions are
1504          const index_t bottomN0=(neighbour%m_NX == 0 ? m_N0 : m_N0-1);      // within bounds
1505          const index_t bottomN1=(neighbour%(m_NX*m_NY)/m_NX==0 ? m_N1 : m_N1-1);      const dim_t numDOF=nDOF0*nDOF1*nDOF2;
1506  #pragma omp parallel for      vector<IndexVector> colIndices(numDOF); // for the couple blocks
1507          for (dim_t i2=front; i2<m_N2; i2++) {      RankVector neighbour;
1508              for (dim_t i0=left; i0<m_N0; i0++) {      IndexVector offsetInShared(1,0);
1509                  m_nodeId[i0+i2*m_N0*m_N1]=m_nodeDistribution[neighbour]      IndexVector sendShared, recvShared;
1510                      + bottomN0*(bottomN1-1)      int numShared=0;
1511                      + (i2-front)*bottomN0*bottomN1 + i0-left;      const int x=m_mpiInfo->rank%m_NX;
1512        const int y=m_mpiInfo->rank%(m_NX*m_NY)/m_NX;
1513        const int z=m_mpiInfo->rank/(m_NX*m_NY);
1514        for (int i2=-1; i2<2; i2++) {
1515            for (int i1=-1; i1<2; i1++) {
1516                for (int i0=-1; i0<2; i0++) {
1517                    // skip this rank
1518                    if (i0==0 && i1==0 && i2==0)
1519                        continue;
1520                    // location of neighbour rank
1521                    const int nx=x+i0;
1522                    const int ny=y+i1;
1523                    const int nz=z+i2;
1524                    if (nx>=0 && ny>=0 && nz>=0 && nx<m_NX && ny<m_NY && nz<m_NZ) {
1525                        neighbour.push_back(nz*m_NX*m_NY+ny*m_NX+nx);
1526                        if (i0==0 && i1==0) {
1527                            // sharing front or back plane
1528                            offsetInShared.push_back(offsetInShared.back()+nDOF0*nDOF1);
1529                            for (dim_t i=0; i<nDOF1; i++) {
1530                                const int firstDOF=(i2==-1 ? i*nDOF0
1531                                        : i*nDOF0 + nDOF0*nDOF1*(nDOF2-1));
1532                                const int firstNode=(i2==-1 ? left+(i+bottom)*m_N0
1533                                        : left+(i+bottom)*m_N0+m_N0*m_N1*(m_N2-1));
1534                                for (dim_t j=0; j<nDOF0; j++, numShared++) {
1535                                    sendShared.push_back(firstDOF+j);
1536                                    recvShared.push_back(numDOF+numShared);
1537                                    if (j>0) {
1538                                        if (i>0)
1539                                            colIndices[firstDOF+j-1-nDOF0].push_back(numShared);
1540                                        colIndices[firstDOF+j-1].push_back(numShared);
1541                                        if (i<nDOF1-1)
1542                                            colIndices[firstDOF+j-1+nDOF0].push_back(numShared);
1543                                    }
1544                                    if (i>0)
1545                                        colIndices[firstDOF+j-nDOF0].push_back(numShared);
1546                                    colIndices[firstDOF+j].push_back(numShared);
1547                                    if (i<nDOF1-1)
1548                                        colIndices[firstDOF+j+nDOF0].push_back(numShared);
1549                                    if (j<nDOF0-1) {
1550                                        if (i>0)
1551                                            colIndices[firstDOF+j+1-nDOF0].push_back(numShared);
1552                                        colIndices[firstDOF+j+1].push_back(numShared);
1553                                        if (i<nDOF1-1)
1554                                            colIndices[firstDOF+j+1+nDOF0].push_back(numShared);
1555                                    }
1556                                    m_dofMap[firstNode+j]=numDOF+numShared;
1557                                }
1558                            }
1559                        } else if (i0==0 && i2==0) {
1560                            // sharing top or bottom plane
1561                            offsetInShared.push_back(offsetInShared.back()+nDOF0*nDOF2);
1562                            for (dim_t i=0; i<nDOF2; i++) {
1563                                const int firstDOF=(i1==-1 ? i*nDOF0*nDOF1
1564                                        : nDOF0*((i+1)*nDOF1-1));
1565                                const int firstNode=(i1==-1 ?
1566                                        left+(i+front)*m_N0*m_N1
1567                                        : left+m_N0*((i+1+front)*m_N1-1));
1568                                for (dim_t j=0; j<nDOF0; j++, numShared++) {
1569                                    sendShared.push_back(firstDOF+j);
1570                                    recvShared.push_back(numDOF+numShared);
1571                                    if (j>0) {
1572                                        if (i>0)
1573                                            colIndices[firstDOF+j-1-nDOF0*nDOF1].push_back(numShared);
1574                                        colIndices[firstDOF+j-1].push_back(numShared);
1575                                        if (i<nDOF2-1)
1576                                            colIndices[firstDOF+j-1+nDOF0*nDOF1].push_back(numShared);
1577                                    }
1578                                    if (i>0)
1579                                        colIndices[firstDOF+j-nDOF0*nDOF1].push_back(numShared);
1580                                    colIndices[firstDOF+j].push_back(numShared);
1581                                    if (i<nDOF2-1)
1582                                        colIndices[firstDOF+j+nDOF0*nDOF1].push_back(numShared);
1583                                    if (j<nDOF0-1) {
1584                                        if (i>0)
1585                                            colIndices[firstDOF+j+1-nDOF0*nDOF1].push_back(numShared);
1586                                        colIndices[firstDOF+j+1].push_back(numShared);
1587                                        if (i<nDOF2-1)
1588                                            colIndices[firstDOF+j+1+nDOF0*nDOF1].push_back(numShared);
1589                                    }
1590                                    m_dofMap[firstNode+j]=numDOF+numShared;
1591                                }
1592                            }
1593                        } else if (i1==0 && i2==0) {
1594                            // sharing left or right plane
1595                            offsetInShared.push_back(offsetInShared.back()+nDOF1*nDOF2);
1596                            for (dim_t i=0; i<nDOF2; i++) {
1597                                const int firstDOF=(i0==-1 ? i*nDOF0*nDOF1
1598                                        : nDOF0*(1+i*nDOF1)-1);
1599                                const int firstNode=(i0==-1 ?
1600                                        (bottom+(i+front)*m_N1)*m_N0
1601                                        : (bottom+1+(i+front)*m_N1)*m_N0-1);
1602                                for (dim_t j=0; j<nDOF1; j++, numShared++) {
1603                                    sendShared.push_back(firstDOF+j*nDOF0);
1604                                    recvShared.push_back(numDOF+numShared);
1605                                    if (j>0) {
1606                                        if (i>0)
1607                                            colIndices[firstDOF+(j-1)*nDOF0-nDOF0*nDOF1].push_back(numShared);
1608                                        colIndices[firstDOF+(j-1)*nDOF0].push_back(numShared);
1609                                        if (i<nDOF2-1)
1610                                            colIndices[firstDOF+(j-1)*nDOF0+nDOF0*nDOF1].push_back(numShared);
1611                                    }
1612                                    if (i>0)
1613                                        colIndices[firstDOF+j*nDOF0-nDOF0*nDOF1].push_back(numShared);
1614                                    colIndices[firstDOF+j*nDOF0].push_back(numShared);
1615                                    if (i<nDOF2-1)
1616                                        colIndices[firstDOF+j*nDOF0+nDOF0*nDOF1].push_back(numShared);
1617                                    if (j<nDOF1-1) {
1618                                        if (i>0)
1619                                            colIndices[firstDOF+(j+1)*nDOF0-nDOF0*nDOF1].push_back(numShared);
1620                                        colIndices[firstDOF+(j+1)*nDOF0].push_back(numShared);
1621                                        if (i<nDOF2-1)
1622                                            colIndices[firstDOF+(j+1)*nDOF0+nDOF0*nDOF1].push_back(numShared);
1623                                    }
1624                                    m_dofMap[firstNode+j*m_N0]=numDOF+numShared;
1625                                }
1626                            }
1627                        } else if (i0==0) {
1628                            // sharing an edge in x direction
1629                            offsetInShared.push_back(offsetInShared.back()+nDOF0);
1630                            const int firstDOF=(i1+1)/2*nDOF0*(nDOF1-1)
1631                                               +(i2+1)/2*nDOF0*nDOF1*(nDOF2-1);
1632                            const int firstNode=(i1+1)/2*m_N0*(m_N1-1)
1633                                                +(i2+1)/2*m_N0*m_N1*(m_N2-1);
1634                            for (dim_t i=0; i<nDOF0; i++, numShared++) {
1635                                sendShared.push_back(firstDOF+i);
1636                                recvShared.push_back(numDOF+numShared);
1637                                if (i>0)
1638                                    colIndices[firstDOF+i-1].push_back(numShared);
1639                                colIndices[firstDOF+i].push_back(numShared);
1640                                if (i<nDOF0-1)
1641                                    colIndices[firstDOF+i+1].push_back(numShared);
1642                                m_dofMap[firstNode+i]=numDOF+numShared;
1643                            }
1644                        } else if (i1==0) {
1645                            // sharing an edge in y direction
1646                            offsetInShared.push_back(offsetInShared.back()+nDOF1);
1647                            const int firstDOF=(i0+1)/2*(nDOF0-1)
1648                                               +(i2+1)/2*nDOF0*nDOF1*(nDOF2-1);
1649                            const int firstNode=(i0+1)/2*(m_N0-1)
1650                                                +(i2+1)/2*m_N0*m_N1*(m_N2-1);
1651                            for (dim_t i=0; i<nDOF1; i++, numShared++) {
1652                                sendShared.push_back(firstDOF+i*nDOF0);
1653                                recvShared.push_back(numDOF+numShared);
1654                                if (i>0)
1655                                    colIndices[firstDOF+(i-1)*nDOF0].push_back(numShared);
1656                                colIndices[firstDOF+i*nDOF0].push_back(numShared);
1657                                if (i<nDOF1-1)
1658                                    colIndices[firstDOF+(i+1)*nDOF0].push_back(numShared);
1659                                m_dofMap[firstNode+i*m_N0]=numDOF+numShared;
1660                            }
1661                        } else if (i2==0) {
1662                            // sharing an edge in z direction
1663                            offsetInShared.push_back(offsetInShared.back()+nDOF2);
1664                            const int firstDOF=(i0+1)/2*(nDOF0-1)
1665                                               +(i1+1)/2*nDOF0*(nDOF1-1);
1666                            const int firstNode=(i0+1)/2*(m_N0-1)
1667                                                +(i1+1)/2*m_N0*(m_N1-1);
1668                            for (dim_t i=0; i<nDOF2; i++, numShared++) {
1669                                sendShared.push_back(firstDOF+i*nDOF0*nDOF1);
1670                                recvShared.push_back(numDOF+numShared);
1671                                if (i>0)
1672                                    colIndices[firstDOF+(i-1)*nDOF0*nDOF1].push_back(numShared);
1673                                colIndices[firstDOF+i*nDOF0*nDOF1].push_back(numShared);
1674                                if (i<nDOF2-1)
1675                                    colIndices[firstDOF+(i+1)*nDOF0*nDOF1].push_back(numShared);
1676                                m_dofMap[firstNode+i*m_N0*m_N1]=numDOF+numShared;
1677                            }
1678                        } else {
1679                            // sharing a node
1680                            const int dof=(i0+1)/2*(nDOF0-1)
1681                                          +(i1+1)/2*nDOF0*(nDOF1-1)
1682                                          +(i2+1)/2*nDOF0*nDOF1*(nDOF2-1);
1683                            const int node=(i0+1)/2*(m_N0-1)
1684                                           +(i1+1)/2*m_N0*(m_N1-1)
1685                                           +(i2+1)/2*m_N0*m_N1*(m_N2-1);
1686                            offsetInShared.push_back(offsetInShared.back()+1);
1687                            sendShared.push_back(dof);
1688                            recvShared.push_back(numDOF+numShared);
1689                            colIndices[dof].push_back(numShared);
1690                            m_dofMap[node]=numDOF+numShared;
1691                            ++numShared;
1692                        }
1693                    }
1694              }              }
1695          }          }
1696      }      }
1697      // case 3: all nodes on front plane are owned by rank in front  
1698      if (front>0) {      // create connector
1699          const int neighbour=m_mpiInfo->rank-m_NX*m_NY;      Paso_SharedComponents *snd_shcomp = Paso_SharedComponents_alloc(
1700          const index_t N0=(neighbour%m_NX == 0 ? m_N0 : m_N0-1);              numDOF, neighbour.size(), &neighbour[0], &sendShared[0],
1701          const index_t N1=(neighbour%(m_NX*m_NY)/m_NX==0 ? m_N1 : m_N1-1);              &offsetInShared[0], 1, 0, m_mpiInfo);
1702          const index_t N2=(neighbour/(m_NX*m_NY)==0 ? m_N2 : m_N2-1);      Paso_SharedComponents *rcv_shcomp = Paso_SharedComponents_alloc(
1703  #pragma omp parallel for              numDOF, neighbour.size(), &neighbour[0], &recvShared[0],
1704          for (dim_t i1=bottom; i1<m_N1; i1++) {              &offsetInShared[0], 1, 0, m_mpiInfo);
1705              for (dim_t i0=left; i0<m_N0; i0++) {      m_connector = Paso_Connector_alloc(snd_shcomp, rcv_shcomp);
1706                  m_nodeId[i0+i1*m_N0]=m_nodeDistribution[neighbour]      Paso_SharedComponents_free(snd_shcomp);
1707                      + N0*N1*(N2-1)+(i1-bottom)*N0 + i0-left;      Paso_SharedComponents_free(rcv_shcomp);
1708              }  
1709          }      // create main and couple blocks
1710        Paso_Pattern *mainPattern = createMainPattern();
1711        Paso_Pattern *colPattern, *rowPattern;
1712        createCouplePatterns(colIndices, numShared, &colPattern, &rowPattern);
1713    
1714        // allocate paso distribution
1715        Paso_Distribution* distribution = Paso_Distribution_alloc(m_mpiInfo,
1716                const_cast<index_t*>(&m_nodeDistribution[0]), 1, 0);
1717    
1718        // finally create the system matrix
1719        m_pattern = Paso_SystemMatrixPattern_alloc(MATRIX_FORMAT_DEFAULT,
1720                distribution, distribution, mainPattern, colPattern, rowPattern,
1721                m_connector, m_connector);
1722    
1723        Paso_Distribution_free(distribution);
1724    
1725        // useful debug output
1726        /*
1727        cout << "--- rcv_shcomp ---" << endl;
1728        cout << "numDOF=" << numDOF << ", numNeighbors=" << neighbour.size() << endl;
1729        for (size_t i=0; i<neighbour.size(); i++) {
1730            cout << "neighbor[" << i << "]=" << neighbour[i]
1731                << " offsetInShared[" << i+1 << "]=" << offsetInShared[i+1] << endl;
1732      }      }
1733      // case 4: nodes on front bottom edge are owned by the corresponding rank      for (size_t i=0; i<recvShared.size(); i++) {
1734      if (front>0 && bottom>0) {          cout << "shared[" << i << "]=" << recvShared[i] << endl;
         const int neighbour=m_mpiInfo->rank-m_NX*(m_NY+1);  
         const index_t N0=(neighbour%m_NX == 0 ? m_N0 : m_N0-1);  
         const index_t N1=(neighbour%(m_NX*m_NY)/m_NX==0 ? m_N1 : m_N1-1);  
         const index_t N2=(neighbour/(m_NX*m_NY)==0 ? m_N2 : m_N2-1);  
 #pragma omp parallel for  
         for (dim_t i0=left; i0<m_N0; i0++) {  
             m_nodeId[i0]=m_nodeDistribution[neighbour]  
                 + N0*N1*(N2-1)+(N1-1)*N0 + i0-left;  
         }  
1735      }      }
1736      // case 5: nodes on left bottom edge are owned by the corresponding rank      cout << "--- snd_shcomp ---" << endl;
1737      if (left>0 && bottom>0) {      for (size_t i=0; i<sendShared.size(); i++) {
1738          const int neighbour=m_mpiInfo->rank-m_NX-1;          cout << "shared[" << i << "]=" << sendShared[i] << endl;
         const index_t N0=(neighbour%m_NX == 0 ? m_N0 : m_N0-1);  
         const index_t N1=(neighbour%(m_NX*m_NY)/m_NX==0 ? m_N1 : m_N1-1);  
 #pragma omp parallel for  
         for (dim_t i2=front; i2<m_N2; i2++) {  
             m_nodeId[i2*m_N0*m_N1]=m_nodeDistribution[neighbour]  
                 + (1+i2-front)*N0*N1-1;  
         }  
1739      }      }
1740      // case 6: nodes on left front edge are owned by the corresponding rank      cout << "--- dofMap ---" << endl;
1741      if (left>0 && front>0) {      for (size_t i=0; i<m_dofMap.size(); i++) {
1742          const int neighbour=m_mpiInfo->rank-m_NX*m_NY-1;          cout << "m_dofMap[" << i << "]=" << m_dofMap[i] << endl;
         const index_t N0=(neighbour%m_NX == 0 ? m_N0 : m_N0-1);  
         const index_t N1=(neighbour%(m_NX*m_NY)/m_NX==0 ? m_N1 : m_N1-1);  
         const index_t N2=(neighbour/(m_NX*m_NY)==0 ? m_N2 : m_N2-1);  
 #pragma omp parallel for  
         for (dim_t i1=bottom; i1<m_N1; i1++) {  
             m_nodeId[i1*m_N0]=m_nodeDistribution[neighbour]  
                 + N0*N1*(N2-1)+N0-1+(i1-bottom)*N0;  
         }  
     }  
     // case 7: bottom-left-front corner node owned by corresponding rank  
     if (left>0 && bottom>0 && front>0) {  
         const int neighbour=m_mpiInfo->rank-m_NX*(m_NY+1)-1;  
         const index_t N0=(neighbour%m_NX == 0 ? m_N0 : m_N0-1);  
         const index_t N1=(neighbour%(m_NX*m_NY)/m_NX==0 ? m_N1 : m_N1-1);  
         const index_t N2=(neighbour/(m_NX*m_NY) == 0 ? m_N2 : m_N2-1);  
         m_nodeId[0]=m_nodeDistribution[neighbour]+N0*N1*N2-1;  
1743      }      }
1744        cout << "--- colIndices ---" << endl;
1745        for (size_t i=0; i<colIndices.size(); i++) {
1746            cout << "colIndices[" << i << "].size()=" << colIndices[i].size() << endl;
1747        }
1748        */
1749    
1750      // the rest of the id's are contiguous      /*
1751      const index_t firstId=m_nodeDistribution[m_mpiInfo->rank];      cout << "--- main_pattern ---" << endl;
1752  #pragma omp parallel for      cout << "M=" << mainPattern->numOutput << ", N=" << mainPattern->numInput << endl;
1753      for (dim_t i2=front; i2<m_N2; i2++) {      for (size_t i=0; i<mainPattern->numOutput+1; i++) {
1754          for (dim_t i1=bottom; i1<m_N1; i1++) {          cout << "ptr[" << i << "]=" << mainPattern->ptr[i] << endl;
1755              for (dim_t i0=left; i0<m_N0; i0++) {      }
1756                  m_nodeId[i0+i1*m_N0+i2*m_N0*m_N1] = firstId+i0-left      for (size_t i=0; i<mainPattern->ptr[mainPattern->numOutput]; i++) {
1757                      +(i1-bottom)*(m_N0-left)          cout << "index[" << i << "]=" << mainPattern->index[i] << endl;
                     +(i2-front)*(m_N0-left)*(m_N1-bottom);  
             }  
         }  
1758      }      }
1759        */
1760    
1761      // elements      /*
1762      m_elementId.resize(getNumElements());      cout << "--- colCouple_pattern ---" << endl;
1763  #pragma omp parallel for      cout << "M=" << colPattern->numOutput << ", N=" << colPattern->numInput << endl;
1764      for (dim_t k=0; k<getNumElements(); k++) {      for (size_t i=0; i<colPattern->numOutput+1; i++) {
1765          m_elementId[k]=k;          cout << "ptr[" << i << "]=" << colPattern->ptr[i] << endl;
1766        }
1767        for (size_t i=0; i<colPattern->ptr[colPattern->numOutput]; i++) {
1768            cout << "index[" << i << "]=" << colPattern->index[i] << endl;
1769      }      }
1770        */
1771    
1772      // face elements      /*
1773      m_faceId.resize(getNumFaceElements());      cout << "--- rowCouple_pattern ---" << endl;
1774        cout << "M=" << rowPattern->numOutput << ", N=" << rowPattern->numInput << endl;
1775        for (size_t i=0; i<rowPattern->numOutput+1; i++) {
1776            cout << "ptr[" << i << "]=" << rowPattern->ptr[i] << endl;
1777        }
1778        for (size_t i=0; i<rowPattern->ptr[rowPattern->numOutput]; i++) {
1779            cout << "index[" << i << "]=" << rowPattern->index[i] << endl;
1780        }
1781        */
1782    
1783        Paso_Pattern_free(mainPattern);
1784        Paso_Pattern_free(colPattern);
1785        Paso_Pattern_free(rowPattern);
1786    }
1787    
1788    //protected
1789    void Brick::interpolateNodesOnElements(escript::Data& out, escript::Data& in,
1790                                           bool reduced) const
1791    {
1792        const dim_t numComp = in.getDataPointSize();
1793        if (reduced) {
1794            /*** GENERATOR SNIP_INTERPOLATE_REDUCED_ELEMENTS TOP */
1795            const double c0 = .125;
1796  #pragma omp parallel for  #pragma omp parallel for
1797      for (dim_t k=0; k<getNumFaceElements(); k++) {          for (index_t k2=0; k2 < m_NE2; ++k2) {
1798          m_faceId[k]=k;              for (index_t k1=0; k1 < m_NE1; ++k1) {
1799                    for (index_t k0=0; k0 < m_NE0; ++k0) {
1800                        const register double* f_000 = in.getSampleDataRO(INDEX3(k0,k1,k2, m_N0,m_N1));
1801                        const register double* f_001 = in.getSampleDataRO(INDEX3(k0,k1,k2+1, m_N0,m_N1));
1802                        const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,k1,k2+1, m_N0,m_N1));
1803                        const register double* f_011 = in.getSampleDataRO(INDEX3(k0,k1+1,k2+1, m_N0,m_N1));
1804                        const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,k1,k2, m_N0,m_N1));
1805                        const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,k1+1,k2, m_N0,m_N1));
1806                        const register double* f_010 = in.getSampleDataRO(INDEX3(k0,k1+1,k2, m_N0,m_N1));
1807                        const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,k1+1,k2+1, m_N0,m_N1));
1808                        double* o = out.getSampleDataRW(INDEX3(k0,k1,k2,m_NE0,m_NE1));
1809                        for (index_t i=0; i < numComp; ++i) {
1810                            o[INDEX2(i,numComp,0)] = c0*(f_000[i] + f_001[i] + f_010[i] + f_011[i] + f_100[i] + f_101[i] + f_110[i] + f_111[i]);
1811                        } /* end of component loop i */
1812                    } /* end of k0 loop */
1813                } /* end of k1 loop */
1814            } /* end of k2 loop */
1815            /* GENERATOR SNIP_INTERPOLATE_REDUCED_ELEMENTS BOTTOM */
1816        } else {
1817            /*** GENERATOR SNIP_INTERPOLATE_ELEMENTS TOP */
1818            const double c0 = .0094373878376559314545;
1819            const double c1 = .035220810900864519624;
1820            const double c2 = .13144585576580214704;
1821            const double c3 = .49056261216234406855;
1822    #pragma omp parallel for
1823            for (index_t k2=0; k2 < m_NE2; ++k2) {
1824                for (index_t k1=0; k1 < m_NE1; ++k1) {
1825                    for (index_t k0=0; k0 < m_NE0; ++k0) {
1826                        const register double* f_000 = in.getSampleDataRO(INDEX3(k0,k1,k2, m_N0,m_N1));
1827                        const register double* f_001 = in.getSampleDataRO(INDEX3(k0,k1,k2+1, m_N0,m_N1));
1828                        const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,k1,k2+1, m_N0,m_N1));
1829                        const register double* f_011 = in.getSampleDataRO(INDEX3(k0,k1+1,k2+1, m_N0,m_N1));
1830                        const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,k1+1,k2, m_N0,m_N1));
1831                        const register double* f_010 = in.getSampleDataRO(INDEX3(k0,k1+1,k2, m_N0,m_N1));
1832                        const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,k1,k2, m_N0,m_N1));
1833                        const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,k1+1,k2+1, m_N0,m_N1));
1834                        double* o = out.getSampleDataRW(INDEX3(k0,k1,k2,m_NE0,m_NE1));
1835                        for (index_t i=0; i < numComp; ++i) {
1836                            o[INDEX2(i,numComp,0)] = f_000[i]*c3 + f_111[i]*c0 + c2*(f_001[i] + f_010[i] + f_100[i]) + c1*(f_011[i] + f_101[i] + f_110[i]);
1837                            o[INDEX2(i,numComp,1)] = f_011[i]*c0 + f_100[i]*c3 + c2*(f_000[i] + f_101[i] + f_110[i]) + c1*(f_001[i] + f_010[i] + f_111[i]);
1838                            o[INDEX2(i,numComp,2)] = f_010[i]*c3 + f_101[i]*c0 + c2*(f_000[i] + f_011[i] + f_110[i]) + c1*(f_001[i] + f_100[i] + f_111[i]);
1839                            o[INDEX2(i,numComp,3)] = f_001[i]*c0 + f_110[i]*c3 + c2*(f_010[i] + f_100[i] + f_111[i]) + c1*(f_000[i] + f_011[i] + f_101[i]);
1840                            o[INDEX2(i,numComp,4)] = f_001[i]*c3 + f_110[i]*c0 + c2*(f_000[i] + f_011[i] + f_101[i]) + c1*(f_010[i] + f_100[i] + f_111[i]);
1841                            o[INDEX2(i,numComp,5)] = f_010[i]*c0 + f_101[i]*c3 + c2*(f_001[i] + f_100[i] + f_111[i]) + c1*(f_000[i] + f_011[i] + f_110[i]);
1842                            o[INDEX2(i,numComp,6)] = f_011[i]*c3 + f_100[i]*c0 + c2*(f_001[i] + f_010[i] + f_111[i]) + c1*(f_000[i] + f_101[i] + f_110[i]);
1843                            o[INDEX2(i,numComp,7)] = f_000[i]*c0 + f_111[i]*c3 + c2*(f_011[i] + f_101[i] + f_110[i]) + c1*(f_001[i] + f_010[i] + f_100[i]);
1844                        } /* end of component loop i */
1845                    } /* end of k0 loop */
1846                } /* end of k1 loop */
1847            } /* end of k2 loop */
1848            /* GENERATOR SNIP_INTERPOLATE_ELEMENTS BOTTOM */
1849      }      }
1850  }  }
1851    
1852    //protected
1853    void Brick::interpolateNodesOnFaces(escript::Data& out, escript::Data& in,
1854                                        bool reduced) const
1855    {
1856        const dim_t numComp = in.getDataPointSize();
1857        if (reduced) {
1858            const double c0 = .25;
1859    #pragma omp parallel
1860            {
1861                /*** GENERATOR SNIP_INTERPOLATE_REDUCED_FACES TOP */
1862                if (m_faceOffset[0] > -1) {
1863    #pragma omp for nowait
1864                    for (index_t k2=0; k2 < m_NE2; ++k2) {
1865                        for (index_t k1=0; k1 < m_NE1; ++k1) {
1866                            const register double* f_011 = in.getSampleDataRO(INDEX3(0,k1+1,k2+1, m_N0,m_N1));
1867                            const register double* f_010 = in.getSampleDataRO(INDEX3(0,k1+1,k2, m_N0,m_N1));
1868                            const register double* f_001 = in.getSampleDataRO(INDEX3(0,k1,k2+1, m_N0,m_N1));
1869                            const register double* f_000 = in.getSampleDataRO(INDEX3(0,k1,k2, m_N0,m_N1));
1870                            double* o = out.getSampleDataRW(m_faceOffset[0]+INDEX2(k1,k2,m_NE1));
1871                            for (index_t i=0; i < numComp; ++i) {
1872                                o[INDEX2(i,numComp,0)] = c0*(f_000[i] + f_001[i] + f_010[i] + f_011[i]);
1873                            } /* end of component loop i */
1874                        } /* end of k1 loop */
1875                    } /* end of k2 loop */
1876                } /* end of face 0 */
1877                if (m_faceOffset[1] > -1) {
1878    #pragma omp for nowait
1879                    for (index_t k2=0; k2 < m_NE2; ++k2) {
1880                        for (index_t k1=0; k1 < m_NE1; ++k1) {
1881                            const register double* f_110 = in.getSampleDataRO(INDEX3(m_N0-1,k1+1,k2, m_N0,m_N1));
1882                            const register double* f_100 = in.getSampleDataRO(INDEX3(m_N0-1,k1,k2, m_N0,m_N1));
1883                            const register double* f_101 = in.getSampleDataRO(INDEX3(m_N0-1,k1,k2+1, m_N0,m_N1));
1884                            const register double* f_111 = in.getSampleDataRO(INDEX3(m_N0-1,k1+1,k2+1, m_N0,m_N1));
1885                            double* o = out.getSampleDataRW(m_faceOffset[1]+INDEX2(k1,k2,m_NE1));
1886                            for (index_t i=0; i < numComp; ++i) {
1887                                o[INDEX2(i,numComp,0)] = c0*(f_100[i] + f_101[i] + f_110[i] + f_111[i]);
1888                            } /* end of component loop i */
1889                        } /* end of k1 loop */
1890                    } /* end of k2 loop */
1891                } /* end of face 1 */
1892                if (m_faceOffset[2] > -1) {
1893    #pragma omp for nowait
1894                    for (index_t k2=0; k2 < m_NE2; ++k2) {
1895                        for (index_t k0=0; k0 < m_NE0; ++k0) {
1896                            const register double* f_000 = in.getSampleDataRO(INDEX3(k0,0,k2, m_N0,m_N1));
1897                            const register double* f_001 = in.getSampleDataRO(INDEX3(k0,0,k2+1, m_N0,m_N1));
1898                            const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,0,k2+1, m_N0,m_N1));
1899                            const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,0,k2, m_N0,m_N1));
1900                            double* o = out.getSampleDataRW(m_faceOffset[2]+INDEX2(k0,k2,m_NE0));
1901                            for (index_t i=0; i < numComp; ++i) {
1902                                o[INDEX2(i,numComp,0)] = c0*(f_000[i] + f_001[i] + f_100[i] + f_101[i]);
1903                            } /* end of component loop i */
1904                        } /* end of k0 loop */
1905                    } /* end of k2 loop */
1906                } /* end of face 2 */
1907                if (m_faceOffset[3] > -1) {
1908    #pragma omp for nowait
1909                    for (index_t k2=0; k2 < m_NE2; ++k2) {
1910                        for (index_t k0=0; k0 < m_NE0; ++k0) {
1911                            const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,m_N1-1,k2, m_N0,m_N1));
1912                            const register double* f_011 = in.getSampleDataRO(INDEX3(k0,m_N1-1,k2+1, m_N0,m_N1));
1913                            const register double* f_010 = in.getSampleDataRO(INDEX3(k0,m_N1-1,k2, m_N0,m_N1));
1914                            const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,m_N1-1,k2+1, m_N0,m_N1));
1915                            double* o = out.getSampleDataRW(m_faceOffset[3]+INDEX2(k0,k2,m_NE0));
1916                            for (index_t i=0; i < numComp; ++i) {
1917                                o[INDEX2(i,numComp,0)] = c0*(f_010[i] + f_011[i] + f_110[i] + f_111[i]);
1918                            } /* end of component loop i */
1919                        } /* end of k0 loop */
1920                    } /* end of k2 loop */
1921                } /* end of face 3 */
1922                if (m_faceOffset[4] > -1) {
1923    #pragma omp for nowait
1924                    for (index_t k1=0; k1 < m_NE1; ++k1) {
1925                        for (index_t k0=0; k0 < m_NE0; ++k0) {
1926                            const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,k1+1,0, m_N0,m_N1));
1927                            const register double* f_010 = in.getSampleDataRO(INDEX3(k0,k1+1,0, m_N0,m_N1));
1928                            const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,k1,0, m_N0,m_N1));
1929                            const register double* f_000 = in.getSampleDataRO(INDEX3(k0,k1,0, m_N0,m_N1));
1930                            double* o = out.getSampleDataRW(m_faceOffset[4]+INDEX2(k0,k1,m_NE0));
1931                            for (index_t i=0; i < numComp; ++i) {
1932                                o[INDEX2(i,numComp,0)] = c0*(f_000[i] + f_010[i] + f_100[i] + f_110[i]);
1933                            } /* end of component loop i */
1934                        } /* end of k0 loop */
1935                    } /* end of k1 loop */
1936                } /* end of face 4 */
1937                if (m_faceOffset[5] > -1) {
1938    #pragma omp for nowait
1939                    for (index_t k1=0; k1 < m_NE1; ++k1) {
1940                        for (index_t k0=0; k0 < m_NE0; ++k0) {
1941                            const register double* f_011 = in.getSampleDataRO(INDEX3(k0,k1+1,m_N2-1, m_N0,m_N1));
1942                            const register double* f_001 = in.getSampleDataRO(INDEX3(k0,k1,m_N2-1, m_N0,m_N1));
1943                            const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,k1,m_N2-1, m_N0,m_N1));
1944                            const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,k1+1,m_N2-1, m_N0,m_N1));
1945                            double* o = out.getSampleDataRW(m_faceOffset[5]+INDEX2(k0,k1,m_NE0));
1946                            for (index_t i=0; i < numComp; ++i) {
1947                                o[INDEX2(i,numComp,0)] = c0*(f_001[i] + f_011[i] + f_101[i] + f_111[i]);
1948                            } /* end of component loop i */
1949                        } /* end of k0 loop */
1950                    } /* end of k1 loop */
1951                } /* end of face 5 */
1952                /* GENERATOR SNIP_INTERPOLATE_REDUCED_FACES BOTTOM */
1953            } // end of parallel section
1954        } else {
1955            const double c0 = 0.044658198738520451079;
1956            const double c1 = 0.16666666666666666667;
1957            const double c2 = 0.62200846792814621559;
1958    #pragma omp parallel
1959            {
1960                /*** GENERATOR SNIP_INTERPOLATE_FACES TOP */
1961                if (m_faceOffset[0] > -1) {
1962    #pragma omp for nowait
1963                    for (index_t k2=0; k2 < m_NE2; ++k2) {
1964                        for (index_t k1=0; k1 < m_NE1; ++k1) {
1965                            const register double* f_000 = in.getSampleDataRO(INDEX3(0,k1,k2, m_N0,m_N1));
1966                            const register double* f_001 = in.getSampleDataRO(INDEX3(0,k1,k2+1, m_N0,m_N1));
1967                            const register double* f_011 = in.getSampleDataRO(INDEX3(0,k1+1,k2+1, m_N0,m_N1));
1968                            const register double* f_010 = in.getSampleDataRO(INDEX3(0,k1+1,k2, m_N0,m_N1));
1969                            double* o = out.getSampleDataRW(m_faceOffset[0]+INDEX2(k1,k2,m_NE1));
1970                            for (index_t i=0; i < numComp; ++i) {
1971                                o[INDEX2(i,numComp,0)] = f_000[i]*c2 + f_011[i]*c0 + c1*(f_001[i] + f_010[i]);
1972                                o[INDEX2(i,numComp,1)] = f_001[i]*c0 + f_010[i]*c2 + c1*(f_000[i] + f_011[i]);
1973                                o[INDEX2(i,numComp,2)] = f_001[i]*c2 + f_010[i]*c0 + c1*(f_000[i] + f_011[i]);
1974                                o[INDEX2(i,numComp,3)] = f_000[i]*c0 + f_011[i]*c2 + c1*(f_001[i] + f_010[i]);
1975                            } /* end of component loop i */
1976                        } /* end of k1 loop */
1977                    } /* end of k2 loop */
1978                } /* end of face 0 */
1979                if (m_faceOffset[1] > -1) {
1980    #pragma omp for nowait
1981                    for (index_t k2=0; k2 < m_NE2; ++k2) {
1982                        for (index_t k1=0; k1 < m_NE1; ++k1) {
1983                            const register double* f_101 = in.getSampleDataRO(INDEX3(m_N0-1,k1,k2+1, m_N0,m_N1));
1984                            const register double* f_100 = in.getSampleDataRO(INDEX3(m_N0-1,k1,k2, m_N0,m_N1));
1985                            const register double* f_110 = in.getSampleDataRO(INDEX3(m_N0-1,k1+1,k2, m_N0,m_N1));
1986                            const register double* f_111 = in.getSampleDataRO(INDEX3(m_N0-1,k1+1,k2+1, m_N0,m_N1));
1987                            double* o = out.getSampleDataRW(m_faceOffset[1]+INDEX2(k1,k2,m_NE1));
1988                            for (index_t i=0; i < numComp; ++i) {
1989                                o[INDEX2(i,numComp,0)] = f_100[i]*c2 + f_111[i]*c0 + c1*(f_101[i] + f_110[i]);
1990                                o[INDEX2(i,numComp,1)] = f_101[i]*c0 + f_110[i]*c2 + c1*(f_100[i] + f_111[i]);
1991                                o[INDEX2(i,numComp,2)] = f_101[i]*c2 + f_110[i]*c0 + c1*(f_100[i] + f_111[i]);
1992                                o[INDEX2(i,numComp,3)] = f_100[i]*c0 + f_111[i]*c2 + c1*(f_101[i] + f_110[i]);
1993                            } /* end of component loop i */
1994                        } /* end of k1 loop */
1995                    } /* end of k2 loop */
1996                } /* end of face 1 */
1997                if (m_faceOffset[2] > -1) {
1998    #pragma omp for nowait
1999                    for (index_t k2=0; k2 < m_NE2; ++k2) {
2000                        for (index_t k0=0; k0 < m_NE0; ++k0) {
2001                            const register double* f_000 = in.getSampleDataRO(INDEX3(k0,0,k2, m_N0,m_N1));
2002                            const register double* f_001 = in.getSampleDataRO(INDEX3(k0,0,k2+1, m_N0,m_N1));
2003                            const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,0,k2+1, m_N0,m_N1));
2004                            const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,0,k2, m_N0,m_N1));
2005                            double* o = out.getSampleDataRW(m_faceOffset[2]+INDEX2(k0,k2,m_NE0));
2006                            for (index_t i=0; i < numComp; ++i) {
2007                                o[INDEX2(i,numComp,0)] = f_000[i]*c2 + f_101[i]*c0 + c1*(f_001[i] + f_100[i]);
2008                                o[INDEX2(i,numComp,1)] = f_001[i]*c0 + f_100[i]*c2 + c1*(f_000[i] + f_101[i]);
2009                                o[INDEX2(i,numComp,2)] = f_001[i]*c2 + f_100[i]*c0 + c1*(f_000[i] + f_101[i]);
2010                                o[INDEX2(i,numComp,3)] = f_000[i]*c0 + f_101[i]*c2 + c1*(f_001[i] + f_100[i]);
2011                            } /* end of component loop i */
2012                        } /* end of k0 loop */
2013                    } /* end of k2 loop */
2014                } /* end of face 2 */
2015                if (m_faceOffset[3] > -1) {
2016    #pragma omp for nowait
2017                    for (index_t k2=0; k2 < m_NE2; ++k2) {
2018                        for (index_t k0=0; k0 < m_NE0; ++k0) {
2019                            const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,m_N1-1,k2, m_N0,m_N1));
2020                            const register double* f_011 = in.getSampleDataRO(INDEX3(k0,m_N1-1,k2+1, m_N0,m_N1));
2021                            const register double* f_010 = in.getSampleDataRO(INDEX3(k0,m_N1-1,k2, m_N0,m_N1));
2022                            const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,m_N1-1,k2+1, m_N0,m_N1));
2023                            double* o = out.getSampleDataRW(m_faceOffset[3]+INDEX2(k0,k2,m_NE0));
2024                            for (index_t i=0; i < numComp; ++i) {
2025                                o[INDEX2(i,numComp,0)] = f_010[i]*c2 + f_111[i]*c0 + c1*(f_011[i] + f_110[i]);
2026                                o[INDEX2(i,numComp,1)] = f_011[i]*c0 + f_110[i]*c2 + c1*(f_010[i] + f_111[i]);
2027                                o[INDEX2(i,numComp,2)] = f_011[i]*c2 + f_110[i]*c0 + c1*(f_010[i] + f_111[i]);
2028                                o[INDEX2(i,numComp,3)] = f_010[i]*c0 + f_111[i]*c2 + c1*(f_011[i] + f_110[i]);
2029                            } /* end of component loop i */
2030                        } /* end of k0 loop */
2031                    } /* end of k2 loop */
2032                } /* end of face 3 */
2033                if (m_faceOffset[4] > -1) {
2034    #pragma omp for nowait
2035                    for (index_t k1=0; k1 < m_NE1; ++k1) {
2036                        for (index_t k0=0; k0 < m_NE0; ++k0) {
2037                            const register double* f_000 = in.getSampleDataRO(INDEX3(k0,k1,0, m_N0,m_N1));
2038                            const register double* f_100 = in.getSampleDataRO(INDEX3(k0+1,k1,0, m_N0,m_N1));
2039                            const register double* f_110 = in.getSampleDataRO(INDEX3(k0+1,k1+1,0, m_N0,m_N1));
2040                            const register double* f_010 = in.getSampleDataRO(INDEX3(k0,k1+1,0, m_N0,m_N1));
2041                            double* o = out.getSampleDataRW(m_faceOffset[4]+INDEX2(k0,k1,m_NE0));
2042                            for (index_t i=0; i < numComp; ++i) {
2043                                o[INDEX2(i,numComp,0)] = f_000[i]*c2 + f_110[i]*c0 + c1*(f_010[i] + f_100[i]);
2044                                o[INDEX2(i,numComp,1)] = f_010[i]*c0 + f_100[i]*c2 + c1*(f_000[i] + f_110[i]);
2045                                o[INDEX2(i,numComp,2)] = f_010[i]*c2 + f_100[i]*c0 + c1*(f_000[i] + f_110[i]);
2046                                o[INDEX2(i,numComp,3)] = f_000[i]*c0 + f_110[i]*c2 + c1*(f_010[i] + f_100[i]);
2047                            } /* end of component loop i */
2048                        } /* end of k0 loop */
2049                    } /* end of k1 loop */
2050                } /* end of face 4 */
2051                if (m_faceOffset[5] > -1) {
2052    #pragma omp for nowait
2053                    for (index_t k1=0; k1 < m_NE1; ++k1) {
2054                        for (index_t k0=0; k0 < m_NE0; ++k0) {
2055                            const register double* f_001 = in.getSampleDataRO(INDEX3(k0,k1,m_N2-1, m_N0,m_N1));
2056                            const register double* f_101 = in.getSampleDataRO(INDEX3(k0+1,k1,m_N2-1, m_N0,m_N1));
2057                            const register double* f_011 = in.getSampleDataRO(INDEX3(k0,k1+1,m_N2-1, m_N0,m_N1));
2058                            const register double* f_111 = in.getSampleDataRO(INDEX3(k0+1,k1+1,m_N2-1, m_N0,m_N1));
2059                            double* o = out.getSampleDataRW(m_faceOffset[5]+INDEX2(k0,k1,m_NE0));
2060                            for (index_t i=0; i < numComp; ++i) {
2061                                o[INDEX2(i,numComp,0)] = f_001[i]*c2 + f_111[i]*c0 + c1*(f_011[i] + f_101[i]);
2062                                o[INDEX2(i,numComp,1)] = f_011[i]*c0 + f_101[i]*c2 + c1*(f_001[i] + f_111[i]);
2063                                o[INDEX2(i,numComp,2)] = f_011[i]*c2 + f_101[i]*c0 + c1*(f_001[i] + f_111[i]);
2064                                o[INDEX2(i,numComp,3)] = f_001[i]*c0 + f_111[i]*c2 + c1*(f_011[i] + f_101[i]);
2065                            } /* end of component loop i */
2066                        } /* end of k0 loop */
2067                    } /* end of k1 loop */
2068                } /* end of face 5 */
2069                /* GENERATOR SNIP_INTERPOLATE_FACES BOTTOM */
2070            } // end of parallel section
2071        }
2072    }
2073    
2074    //protected
2075    void Brick::assemblePDESingle(Paso_SystemMatrix* mat, escript::Data& rhs,
2076            const escript::Data& A, const escript::Data& B,
2077            const escript::Data& C, const escript::Data& D,
2078            const escript::Data& X, const escript::Data& Y,
2079            const escript::Data& d, const escript::Data& y) const
2080    {
2081        const double h0 = m_l0/m_gNE0;
2082        const double h1 = m_l1/m_gNE1;
2083        const double h2 = m_l2/m_gNE2;
2084        /* GENERATOR SNIP_PDE_SINGLE_PRE TOP */
2085        const double w0 = 0.0009303791403858427308*h1*h2/h0;
2086        const double w1 = 0.0009303791403858427308*h2;
2087        const double w10 = 0.012958509748503046158*h0*h2/h1;
2088        const double w100 = 0.038141762351741127649*h0*h1;
2089        const double w101 = 0.000052682092703316795705*h0*h1;
2090        const double w102 = 0.0007337668937680108255*h0*h1;
2091        const double w103 = 0.010220054420048834761*h0*h1;
2092        const double w104 = -0.0001966122466178319053*h1*h2;
2093        const double w105 = -0.0001966122466178319053*h0*h2;
2094        const double w106 = -0.0007337668937680108255*h1*h2;
2095        const double w107 = -0.0007337668937680108255*h0*h2;
2096        const double w108 = -0.0027384553284542113967*h1*h2;
2097        const double w109 = -0.0027384553284542113967*h0*h2;
2098        const double w11 = -0.0034722222222222222222*h0;
2099        const double w110 = -0.010220054420048834761*h1*h2;
2100        const double w111 = -0.010220054420048834761*h0*h2;
2101        const double w112 = -0.0007337668937680108255*h0*h1;
2102        const double w113 = -0.010220054420048834761*h0*h1;
2103        const double w114 = -0.038141762351741127649*h0*h2;
2104        const double w115 = -0.000052682092703316795705*h0*h2;
2105        const double w116 = -0.0001966122466178319053*h0*h1;
2106        const double w117 = -0.0027384553284542113967*h0*h1;
2107        const double w118 = 0.000052682092703316795705*h0*h2;
2108        const double w119 = 0.038141762351741127649*h0*h2;
2109        const double w12 = 0.0034722222222222222222*h1;
2110        const double w120 = 0.000052682092703316795705*h1*h2;
2111        const double w121 = 0.038141762351741127649*h1*h2;
2112        const double w122 = -0.000052682092703316795705*h0*h1;
2113        const double w123 = -0.038141762351741127649*h0*h1;
2114        const double w124 = -0.000052682092703316795705*h1*h2;
2115        const double w125 = -0.038141762351741127649*h1*h2;
2116        const double w126 = 0.027777777777777777778*h1*h2;
2117        const double w127 = 0.027777777777777777778*h0*h2;
2118        const double w128 = 0.055555555555555555556*h0*h1;
2119        const double w129 = -0.027777777777777777778*h1*h2;
2120        const double w13 = 0.012958509748503046158*h0;
2121        const double w130 = -0.027777777777777777778*h0*h2;
2122        const double w131 = 0.013888888888888888889*h0*h1;
2123        const double w132 = -0.055555555555555555556*h0*h2;
2124        const double w133 = -0.027777777777777777778*h0*h1;
2125        const double w134 = 0.055555555555555555556*h0*h2;
2126        const double w135 = 0.027777777777777777778*h0*h1;
2127        const double w136 = -0.013888888888888888889*h0*h1;
2128        const double w137 = 0.055555555555555555556*h1*h2;
2129        const double w138 = -0.013888888888888888889*h1*h2;
2130        const double w139 = -0.013888888888888888889*h0*h2;
2131        const double w14 = -0.0034722222222222222222*h0*h1/h2;
2132        const double w140 = -0.055555555555555555556*h0*h1;
2133        const double w141 = 0.013888888888888888889*h1*h2;
2134        const double w142 = 0.013888888888888888889*h0*h2;
2135        const double w143 = -0.055555555555555555556*h1*h2;
2136        const double w144 = 0.000041549056553524783501*h0*h1*h2;
2137        const double w145 = 0.0005787037037037037037*h0*h1*h2;
2138        const double w146 = 0.0080603027952983270684*h0*h1*h2;
2139        const double w147 = 0.0001550631900643071218*h0*h1*h2;
2140        const double w148 = 0.002159751624750507693*h0*h1*h2;
2141        const double w149 = 0.03008145955644280058*h0*h1*h2;
2142        const double w15 = 0.012958509748503046158*h1*h2/h0;
2143        const double w150 = 0.000011133036149792012204*h0*h1*h2;
2144        const double w151 = 0.018518518518518518519*h0*h1*h2;
2145        const double w152 = 0.0092592592592592592592*h0*h1*h2;
2146        const double w153 = 0.0046296296296296296296*h0*h1*h2;
2147        const double w154 = 0.037037037037037037037*h0*h1*h2;
2148        const double w155 = -0.077751058491018276949*h1*h2;
2149        const double w156 = -0.077751058491018276949*h0*h2;
2150        const double w157 = -0.077751058491018276949*h0*h1;
2151        const double w158 = -0.020833333333333333333*h0*h2;
2152        const double w159 = -0.020833333333333333333*h0*h1;
2153        const double w16 = -0.0034722222222222222222*h1;
2154        const double w160 = -0.020833333333333333333*h1*h2;
2155        const double w161 = -0.0055822748423150563848*h0*h1;
2156        const double w162 = -0.0055822748423150563848*h0*h2;
2157        const double w163 = -0.0055822748423150563848*h1*h2;
2158        const double w164 = 0.077751058491018276949*h1*h2;
2159        const double w165 = 0.020833333333333333333*h1*h2;
2160        const double w166 = 0.0055822748423150563848*h1*h2;
2161        const double w167 = 0.077751058491018276949*h0*h2;
2162        const double w168 = 0.020833333333333333333*h0*h2;
2163        const double w169 = 0.0055822748423150563848*h0*h2;
2164        const double w17 = -0.0009303791403858427308*h0;
2165        const double w170 = 0.077751058491018276949*h0*h1;
2166        const double w171 = 0.020833333333333333333*h0*h1;
2167        const double w172 = 0.0055822748423150563848*h0*h1;
2168        const double w173 = -0.25*h1*h2;
2169        const double w174 = -0.25*h0*h2;
2170        const double w175 = -0.25*h0*h1;
2171        const double w176 = 0.25*h1*h2;
2172        const double w177 = 0.25*h0*h2;
2173        const double w178 = 0.25*h0*h1;
2174        const double w179 = 0.061320326520293008568*h0*h1*h2;
2175        const double w18 = 0.012958509748503046158*h1;
2176        const double w180 = 0.01643073197072526838*h0*h1*h2;
2177        const double w181 = 0.004402601362608064953*h0*h1*h2;
2178        const double w182 = 0.0011796734797069914318*h0*h1*h2;
2179        const double w183 = 0.125*h0*h1*h2;
2180        const double w19 = 0.0034722222222222222222*h0;
2181        const double w2 = -0.00024929433932114870101*h1;
2182        const double w20 = 0.012958509748503046158*h2;
2183        const double w21 = -0.012958509748503046158*h1;
2184        const double w22 = -0.012958509748503046158*h0;
2185        const double w23 = 0.04836181677178996241*h1;
2186        const double w24 = 0.04836181677178996241*h0;
2187        const double w25 = -0.04836181677178996241*h0*h1/h2;
2188        const double w26 = 0.00024929433932114870101*h1;
2189        const double w27 = 0.00024929433932114870101*h0;
2190        const double w28 = -0.04836181677178996241*h1;
2191        const double w29 = -0.04836181677178996241*h0;
2192        const double w3 = 0.0009303791403858427308*h0*h2/h1;
2193        const double w30 = -0.0009303791403858427308*h1*h2/h0;
2194        const double w31 = -0.0009303791403858427308*h2;
2195        const double w32 = -0.0009303791403858427308*h0*h2/h1;
2196        const double w33 = 0.0034722222222222222222*h0*h1/h2;
2197        const double w34 = -0.0034722222222222222222*h2;
2198        const double w35 = -0.00024929433932114870101*h2;
2199        const double w36 = -0.012958509748503046158*h1*h2/h0;
2200        const double w37 = -0.012958509748503046158*h2;
2201        const double w38 = -0.012958509748503046158*h0*h2/h1;
2202        const double w39 = -0.04836181677178996241*h2;
2203        const double w4 = -0.00024929433932114870101*h0;
2204        const double w40 = -0.0034722222222222222222*h0*h2/h1;
2205        const double w41 = 0.0009303791403858427308*h0*h1/h2;
2206        const double w42 = 0.04836181677178996241*h2;
2207        const double w43 = -0.04836181677178996241*h0*h2/h1;
2208        const double w44 = 0.012958509748503046158*h0*h1/h2;
2209        const double w45 = -0.00024929433932114870101*h0*h2/h1;
2210        const double w46 = 0.00024929433932114870101*h2;
2211        const double w47 = -0.0034722222222222222222*h1*h2/h0;
2212        const double w48 = -0.00024929433932114870101*h1*h2/h0;
2213        const double w49 = -0.04836181677178996241*h1*h2/h0;
2214        const double w5 = 0.0009303791403858427308*h1;
2215        const double w50 = 0.0034722222222222222222*h0*h2/h1;
2216        const double w51 = -0.0009303791403858427308*h0*h1/h2;
2217        const double w52 = -0.012958509748503046158*h0*h1/h2;
2218        const double w53 = 0.0034722222222222222222*h1*h2/h0;
2219        const double w54 = 0.00024929433932114870101*h0*h1/h2;
2220        const double w55 = 0.04836181677178996241*h0*h2/h1;
2221        const double w56 = 0.04836181677178996241*h1*h2/h0;
2222        const double w57 = 0.04836181677178996241*h0*h1/h2;
2223        const double w58 = 0.00024929433932114870101*h1*h2/h0;
2224        const double w59 = 0.00024929433932114870101*h0*h2/h1;
2225        const double w6 = 0.0009303791403858427308*h0;
2226        const double w60 = 0.055555555555555555556*h1*h2/h0;
2227        const double w61 = 0.041666666666666666667*h2;
2228        const double w62 = -0.083333333333333333333*h1;
2229        const double w63 = 0.055555555555555555556*h0*h2/h1;
2230        const double w64 = -0.083333333333333333333*h0;
2231        const double w65 = 0.083333333333333333333*h1;
2232        const double w66 = 0.083333333333333333333*h0;
2233        const double w67 = -0.11111111111111111111*h0*h1/h2;
2234        const double w68 = -0.055555555555555555556*h1*h2/h0;
2235        const double w69 = -0.083333333333333333333*h2;
2236        const double w7 = -0.00024929433932114870101*h0*h1/h2;
2237        const double w70 = -0.041666666666666666667*h1;
2238        const double w71 = -0.055555555555555555556*h0*h2/h1;
2239        const double w72 = -0.041666666666666666667*h0;
2240        const double w73 = 0.041666666666666666667*h1;
2241        const double w74 = 0.041666666666666666667*h0;
2242        const double w75 = 0.027777777777777777778*h0*h1/h2;
2243        const double w76 = 0.083333333333333333333*h2;
2244        const double w77 = -0.11111111111111111111*h0*h2/h1;
2245        const double w78 = 0.055555555555555555556*h0*h1/h2;
2246        const double w79 = -0.11111111111111111111*h1*h2/h0;
2247        const double w8 = 0.0034722222222222222222*h2;
2248        const double w80 = -0.027777777777777777778*h1*h2/h0;
2249        const double w81 = -0.041666666666666666667*h2;
2250        const double w82 = -0.027777777777777777778*h0*h2/h1;
2251        const double w83 = -0.027777777777777777778*h0*h1/h2;
2252        const double w84 = 0.027777777777777777778*h0*h2/h1;
2253        const double w85 = -0.055555555555555555556*h0*h1/h2;
2254        const double w86 = 0.11111111111111111111*h1*h2/h0;
2255        const double w87 = 0.11111111111111111111*h0*h2/h1;
2256        const double w88 = 0.11111111111111111111*h0*h1/h2;
2257        const double w89 = 0.027777777777777777778*h1*h2/h0;
2258        const double w9 = -0.0009303791403858427308*h1;
2259        const double w90 = 0.0001966122466178319053*h1*h2;
2260        const double w91 = 0.0001966122466178319053*h0*h2;
2261        const double w92 = 0.0001966122466178319053*h0*h1;
2262        const double w93 = 0.0007337668937680108255*h1*h2;
2263        const double w94 = 0.0027384553284542113967*h0*h2;
2264        const double w95 = 0.0027384553284542113967*h0*h1;
2265        const double w96 = 0.0027384553284542113967*h1*h2;
2266        const double w97 = 0.0007337668937680108255*h0*h2;
2267        const double w98 = 0.010220054420048834761*h1*h2;
2268        const double w99 = 0.010220054420048834761*h0*h2;
2269        /* GENERATOR SNIP_PDE_SINGLE_PRE BOTTOM */
2270    
2271        rhs.requireWrite();
2272    #pragma omp parallel
2273        {
2274            for (index_t k2_0=0; k2_0<2; k2_0++) { // colouring
2275    #pragma omp for
2276                for (index_t k2=k2_0; k2<m_NE2; k2+=2) {
2277                    for (index_t k1=0; k1<m_NE1; ++k1) {
2278                        for (index_t k0=0; k0<m_NE0; ++k0)  {
2279                            bool add_EM_S=false;
2280                            bool add_EM_F=false;
2281                            vector<double> EM_S(8*8, 0);
2282                            vector<double> EM_F(8, 0);
2283                            const index_t e = k0 + m_NE0*k1 + m_NE0*m_NE1*k2;
2284                            /* GENERATOR SNIP_PDE_SINGLE TOP */
2285                            ///////////////
2286                            // process A //
2287                            ///////////////
2288                            if (!A.isEmpty()) {
2289                                add_EM_S=true;
2290                                const double* A_p=const_cast<escript::Data*>(&A)->getSampleDataRO(e);
2291                                if (A.actsExpanded()) {
2292                                    const register double A_00_0 = A_p[INDEX3(0,0,0,3,3)];
2293                                    const register double A_01_0 = A_p[INDEX3(0,1,0,3,3)];
2294                                    const register double A_02_0 = A_p[INDEX3(0,2,0,3,3)];
2295                                    const register double A_10_0 = A_p[INDEX3(1,0,0,3,3)];
2296                                    const register double A_11_0 = A_p[INDEX3(1,1,0,3,3)];
2297                                    const register double A_12_0 = A_p[INDEX3(1,2,0,3,3)];
2298                                    const register double A_20_0 = A_p[INDEX3(2,0,0,3,3)];
2299                                    const register double A_21_0 = A_p[INDEX3(2,1,0,3,3)];
2300                                    const register double A_22_0 = A_p[INDEX3(2,2,0,3,3)];
2301                                    const register double A_00_1 = A_p[INDEX3(0,0,1,3,3)];
2302                                    const register double A_01_1 = A_p[INDEX3(0,1,1,3,3)];
2303                                    const register double A_02_1 = A_p[INDEX3(0,2,1,3,3)];
2304                                    const register double A_10_1 = A_p[INDEX3(1,0,1,3,3)];
2305                                    const register double A_11_1 = A_p[INDEX3(1,1,1,3,3)];
2306                                    const register double A_12_1 = A_p[INDEX3(1,2,1,3,3)];
2307                                    const register double A_20_1 = A_p[INDEX3(2,0,1,3,3)];
2308                                    const register double A_21_1 = A_p[INDEX3(2,1,1,3,3)];
2309                                    const register double A_22_1 = A_p[INDEX3(2,2,1,3,3)];
2310                                    const register double A_00_2 = A_p[INDEX3(0,0,2,3,3)];
2311                                    const register double A_01_2 = A_p[INDEX3(0,1,2,3,3)];
2312                                    const register double A_02_2 = A_p[INDEX3(0,2,2,3,3)];
2313                                    const register double A_10_2 = A_p[INDEX3(1,0,2,3,3)];
2314                                    const register double A_11_2 = A_p[INDEX3(1,1,2,3,3)];
2315                                    const register double A_12_2 = A_p[INDEX3(1,2,2,3,3)];
2316                                    const register double A_20_2 = A_p[INDEX3(2,0,2,3,3)];
2317                                    const register double A_21_2 = A_p[INDEX3(2,1,2,3,3)];
2318                                    const register double A_22_2 = A_p[INDEX3(2,2,2,3,3)];
2319                                    const register double A_00_3 = A_p[INDEX3(0,0,3,3,3)];
2320                                    const register double A_01_3 = A_p[INDEX3(0,1,3,3,3)];
2321                                    const register double A_02_3 = A_p[INDEX3(0,2,3,3,3)];
2322                                    const register double A_10_3 = A_p[INDEX3(1,0,3,3,3)];
2323                                    const register double A_11_3 = A_p[INDEX3(1,1,3,3,3)];
2324                                    const register double A_12_3 = A_p[INDEX3(1,2,3,3,3)];
2325                                    const register double A_20_3 = A_p[INDEX3(2,0,3,3,3)];
2326                                    const register double A_21_3 = A_p[INDEX3(2,1,3,3,3)];
2327                                    const register double A_22_3 = A_p[INDEX3(2,2,3,3,3)];
2328                                    const register double A_00_4 = A_p[INDEX3(0,0,4,3,3)];
2329                                    const register double A_01_4 = A_p[INDEX3(0,1,4,3,3)];
2330                                    const register double A_02_4 = A_p[INDEX3(0,2,4,3,3)];
2331                                    const register double A_10_4 = A_p[INDEX3(1,0,4,3,3)];
2332                                    const register double A_11_4 = A_p[INDEX3(1,1,4,3,3)];
2333                                    const register double A_12_4 = A_p[INDEX3(1,2,4,3,3)];
2334                                    const register double A_20_4 = A_p[INDEX3(2,0,4,3,3)];
2335                                    const register double A_21_4 = A_p[INDEX3(2,1,4,3,3)];
2336                                    const register double A_22_4 = A_p[INDEX3(2,2,4,3,3)];
2337                                    const register double A_00_5 = A_p[INDEX3(0,0,5,3,3)];
2338                                    const register double A_01_5 = A_p[INDEX3(0,1,5,3,3)];
2339                                    const register double A_02_5 = A_p[INDEX3(0,2,5,3,3)];
2340                                    const register double A_10_5 = A_p[INDEX3(1,0,5,3,3)];
2341                                    const register double A_11_5 = A_p[INDEX3(1,1,5,3,3)];
2342                                    const register double A_12_5 = A_p[INDEX3(1,2,5,3,3)];
2343                                    const register double A_20_5 = A_p[INDEX3(2,0,5,3,3)];
2344                                    const register double A_21_5 = A_p[INDEX3(2,1,5,3,3)];
2345                                    const register double A_22_5 = A_p[INDEX3(2,2,5,3,3)];
2346                                    const register double A_00_6 = A_p[INDEX3(0,0,6,3,3)];
2347                                    const register double A_01_6 = A_p[INDEX3(0,1,6,3,3)];
2348                                    const register double A_02_6 = A_p[INDEX3(0,2,6,3,3)];
2349                                    const register double A_10_6 = A_p[INDEX3(1,0,6,3,3)];
2350                                    const register double A_11_6 = A_p[INDEX3(1,1,6,3,3)];
2351                                    const register double A_12_6 = A_p[INDEX3(1,2,6,3,3)];
2352                                    const register double A_20_6 = A_p[INDEX3(2,0,6,3,3)];
2353                                    const register double A_21_6 = A_p[INDEX3(2,1,6,3,3)];
2354                                    const register double A_22_6 = A_p[INDEX3(2,2,6,3,3)];
2355                                    const register double A_00_7 = A_p[INDEX3(0,0,7,3,3)];
2356                                    const register double A_01_7 = A_p[INDEX3(0,1,7,3,3)];
2357                                    const register double A_02_7 = A_p[INDEX3(0,2,7,3,3)];
2358                                    const register double A_10_7 = A_p[INDEX3(1,0,7,3,3)];
2359                                    const register double A_11_7 = A_p[INDEX3(1,1,7,3,3)];
2360                                    const register double A_12_7 = A_p[INDEX3(1,2,7,3,3)];
2361                                    const register double A_20_7 = A_p[INDEX3(2,0,7,3,3)];
2362                                    const register double A_21_7 = A_p[INDEX3(2,1,7,3,3)];
2363                                    const register double A_22_7 = A_p[INDEX3(2,2,7,3,3)];
2364                                    const register double tmp160_0 = A_12_0 + A_12_6 + A_21_0 + A_21_6;
2365                                    const register double tmp8_0 = A_21_0 + A_21_6;
2366                                    const register double tmp135_0 = A_10_1 + A_10_2 + A_10_5 + A_10_6;
2367                                    const register double tmp67_0 = A_02_2 + A_02_7;
2368                                    const register double tmp211_0 = A_12_6 + A_21_6;
2369                                    const register double tmp180_0 = A_10_2 + A_10_6;
2370                                    const register double tmp37_0 = A_00_0 + A_00_1 + A_00_2 + A_00_3;
2371                                    const register double tmp92_0 = A_11_0 + A_11_1 + A_11_2 + A_11_3 + A_11_4 + A_11_5 + A_11_6 + A_11_7;
2372                                    const register double tmp195_0 = A_02_2 + A_20_2;
2373                                    const register double tmp70_0 = A_01_0 + A_01_7;
2374                                    const register double tmp139_0 = A_02_3 + A_02_4 + A_20_1 + A_20_6;
2375                                    const register double tmp200_0 = A_12_3 + A_12_5 + A_21_3 + A_21_5;
2376                                    const register double tmp60_0 = A_22_0 + A_22_2 + A_22_4 + A_22_6;
2377                                    const register double tmp192_0 = A_01_5 + A_10_5;
2378                                    const register double tmp46_0 = A_21_0 + A_21_7;
2379                                    const register double tmp48_0 = A_10_0 + A_10_7;
2380                                    const register double tmp166_0 = A_11_5 + A_11_7;
2381                                    const register double tmp221_0 = A_02_1 + A_02_6 + A_20_3 + A_20_4;
2382                                    const register double tmp50_0 = A_02_4 + A_02_6 + A_20_4 + A_20_6;
2383                                    const register double tmp217_0 = A_02_3 + A_02_4 + A_20_3 + A_20_4;
2384                                    const register double tmp216_0 = A_01_2 + A_01_5 + A_10_2 + A_10_5;
2385                                    const register double tmp104_0 = A_22_2 + A_22_6;
2386                                    const register double tmp72_0 = A_20_3 + A_20_6;
2387                                    const register double tmp79_0 = A_10_4 + A_10_7;
2388                                    const register double tmp86_0 = A_01_2 + A_01_6 + A_10_1 + A_10_5;
2389                                    const register double tmp214_0 = A_12_0 + A_12_7 + A_21_0 + A_21_7;
2390                                    const register double tmp32_0 = A_02_0 + A_02_2;
2391                                    const register double tmp112_0 = A_01_0 + A_01_4 + A_10_3 + A_10_7;
2392                                    const register double tmp197_0 = A_12_0 + A_21_0;
2393                                    const register double tmp106_0 = A_22_1 + A_22_5;
2394                                    const register double tmp2_0 = A_00_0 + A_00_1 + A_00_4 + A_00_5;
2395                                    const register double tmp115_0 = A_02_5 + A_02_7 + A_20_0 + A_20_2;
2396                                    const register double tmp175_0 = A_01_3 + A_01_7;
2397                                    const register double tmp126_0 = A_01_2 + A_01_5 + A_10_1 + A_10_6;
2398                                    const register double tmp90_0 = A_00_0 + A_00_1 + A_00_2 + A_00_3 + A_00_4 + A_00_5 + A_00_6 + A_00_7;
2399                                    const register double tmp47_0 = A_12_0 + A_12_6;
2400                                    const register double tmp205_0 = A_02_7 + A_20_7;
2401                                    const register double tmp148_0 = A_01_3 + A_01_4;
2402                                    const register double tmp113_0 = A_01_3 + A_01_7 + A_10_0 + A_10_4;
2403                                    const register double tmp43_0 = A_20_4 + A_20_6;
2404                                    const register double tmp161_0 = A_02_1 + A_02_6 + A_20_1 + A_20_6;
2405                                    const register double tmp69_0 = A_12_0 + A_12_1 + A_12_6 + A_12_7 + A_21_0 + A_21_1 + A_21_6 + A_21_7;
2406                                    const register double tmp176_0 = A_01_1 + A_01_2 + A_01_5 + A_01_6;
2407                                    const register double tmp105_0 = A_01_2 + A_01_6 + A_10_2 + A_10_6;
2408                                    const register double tmp22_0 = A_01_5 + A_10_6;
2409                                    const register double tmp91_0 = A_02_4 + A_02_6 + A_20_1 + A_20_3;
2410                                    const register double tmp206_0 = A_12_7 + A_21_7;
2411                                    const register double tmp188_0 = A_02_5 + A_20_5;
2412                                    const register double tmp117_0 = A_21_1 + A_21_6;
2413                                    const register double tmp165_0 = A_01_1 + A_01_6;
2414                                    const register double tmp66_0 = A_00_4 + A_00_5;
2415                                    const register double tmp57_0 = A_02_0 + A_02_2 + A_02_5 + A_02_7 + A_20_0 + A_20_2 + A_20_5 + A_20_7;
2416                                    const register double tmp31_0 = A_21_4 + A_21_5;
2417                                    const register double tmp3_0 = A_11_0 + A_11_2 + A_11_4 + A_11_6;
2418                                    const register double tmp183_0 = A_12_0 + A_12_7;
2419                                    const register double tmp61_0 = A_02_1 + A_02_3 + A_20_1 + A_20_3;
2420                                    const register double tmp54_0 = A_10_5 + A_10_6;
2421                                    const register double tmp18_0 = A_02_3 + A_02_6;
2422                                    const register double tmp119_0 = A_12_2 + A_12_3 + A_12_4 + A_12_5 + A_21_2 + A_21_3 + A_21_4 + A_21_5;
2423                                    const register double tmp29_0 = A_21_2 + A_21_3;
2424                                    const register double tmp17_0 = A_01_3 + A_01_7 + A_10_3 + A_10_7;
2425                                    const register double tmp212_0 = A_02_6 + A_20_6;
2426                                    const register double tmp220_0 = A_02_3 + A_20_6;
2427                                    const register double tmp78_0 = A_20_0 + A_20_7;
2428                                    const register double tmp215_0 = A_01_6 + A_10_6;
2429                                    const register double tmp203_0 = A_01_7 + A_10_7;
2430                                    const register double tmp87_0 = A_12_2 + A_12_3 + A_21_4 + A_21_5;
2431                                    const register double tmp114_0 = A_02_0 + A_02_2 + A_20_5 + A_20_7;
2432                                    const register double tmp0_0 = A_01_0 + A_01_4 + A_10_0 + A_10_4;
2433                                    const register double tmp202_0 = A_01_3 + A_01_4 + A_10_3 + A_10_4;
2434                                    const register double tmp4_0 = A_20_0 + A_20_5;
2435                                    const register double tmp65_0 = A_00_2 + A_00_3;
2436                                    const register double tmp24_0 = A_20_1 + A_20_3;
2437                                    const register double tmp64_0 = A_10_0 + A_10_3;
2438                                    const register double tmp170_0 = A_02_0 + A_02_2 + A_20_0 + A_20_2;
2439                                    const register double tmp11_0 = A_20_1 + A_20_6;
2440                                    const register double tmp82_0 = A_12_4 + A_12_5 + A_21_4 + A_21_5;
2441                                    const register double tmp99_0 = A_01_4 + A_10_7;
2442                                    const register double tmp49_0 = A_12_1 + A_12_7;
2443                                    const register double tmp130_0 = A_12_0 + A_12_1 + A_12_6 + A_12_7;
2444                                    const register double tmp144_0 = A_01_0 + A_10_3;
2445                                    const register double tmp109_0 = A_22_0 + A_22_3 + A_22_4 + A_22_7;
2446                                    const register double tmp185_0 = A_02_0 + A_02_7 + A_20_2 + A_20_5;
2447                                    const register double tmp157_0 = A_01_4 + A_10_4;
2448                                    const register double tmp51_0 = A_22_1 + A_22_3 + A_22_5 + A_22_7;
2449                                    const register double tmp146_0 = A_00_6 + A_00_7;
2450                                    const register double tmp147_0 = A_12_0 + A_12_1 + A_21_0 + A_21_1;
2451                                    const register double tmp150_0 = A_00_2 + A_00_3 + A_00_4 + A_00_5;
2452                                    const register double tmp62_0 = A_21_3 + A_21_5;
2453                                    const register double tmp223_0 = A_12_2 + A_21_4;
2454                                    const register double tmp16_0 = A_02_2 + A_02_5;
2455                                    const register double tmp168_0 = A_11_1 + A_11_3 + A_11_4 + A_11_6;
2456                                    const register double tmp88_0 = A_12_4 + A_12_5 + A_21_2 + A_21_3;
2457                                    const register double tmp142_0 = A_01_7 + A_10_4;
2458                                    const register double tmp34_0 = A_20_0 + A_20_2 + A_20_5 + A_20_7;
2459                                    const register double tmp71_0 = A_00_0 + A_00_1 + A_00_6 + A_00_7;
2460                                    const register double tmp213_0 = A_02_1 + A_20_1;
2461                                    const register double tmp227_0 = A_12_2 + A_12_5 + A_21_3 + A_21_4;
2462                                    const register double tmp228_0 = A_12_1 + A_21_7;
2463                                    const register double tmp140_0 = A_01_2 + A_01_6;
2464                                    const register double tmp74_0 = A_22_0 + A_22_1 + A_22_4 + A_22_5;
2465                                    const register double tmp167_0 = A_11_0 + A_11_2;
2466                                    const register double tmp143_0 = A_01_3 + A_01_4 + A_10_0 + A_10_7;
2467                                    const register double tmp83_0 = A_02_0 + A_02_5;
2468                                    const register double tmp14_0 = A_22_1 + A_22_2 + A_22_5 + A_22_6;
2469                                    const register double tmp5_0 = A_12_1 + A_12_6;
2470                                    const register double tmp94_0 = A_02_1 + A_02_3;
2471                                    const register double tmp193_0 = A_01_1 + A_01_6 + A_10_1 + A_10_6;
2472                                    const register double tmp97_0 = A_02_0 + A_02_2 + A_02_5 + A_02_7;
2473                                    const register double tmp131_0 = A_01_1 + A_01_5;
2474                                    const register double tmp124_0 = A_01_6 + A_10_5;
2475                                    const register double tmp149_0 = A_12_6 + A_12_7 + A_21_6 + A_21_7;
2476                                    const register double tmp187_0 = A_01_2 + A_10_2;
2477                                    const register double tmp93_0 = A_01_1 + A_01_2 + A_10_1 + A_10_2;
2478                                    const register double tmp25_0 = A_01_4 + A_01_7 + A_10_4 + A_10_7;
2479                                    const register double tmp156_0 = A_12_2 + A_12_5 + A_21_2 + A_21_5;
2480                                    const register double tmp20_0 = A_21_2 + A_21_5;
2481                                    const register double tmp55_0 = A_21_2 + A_21_4;
2482                                    const register double tmp208_0 = A_12_1 + A_12_6 + A_21_0 + A_21_7;
2483                                    const register double tmp125_0 = A_12_4 + A_12_5;
2484                                    const register double tmp158_0 = A_01_0 + A_01_7 + A_10_0 + A_10_7;
2485                                    const register double tmp108_0 = A_01_1 + A_01_5 + A_10_1 + A_10_5;
2486                                    const register double tmp199_0 = A_12_2 + A_12_4 + A_21_2 + A_21_4;
2487                                    const register double tmp10_0 = A_02_1 + A_02_4;
2488                                    const register double tmp182_0 = A_02_3 + A_02_6 + A_20_3 + A_20_6;
2489                                    const register double tmp132_0 = A_02_1 + A_20_4;
2490                                    const register double tmp191_0 = A_12_3 + A_12_4 + A_21_3 + A_21_4;
2491                                    const register double tmp35_0 = A_11_0 + A_11_1 + A_11_2 + A_11_3;
2492                                    const register double tmp164_0 = A_10_3 + A_10_4;
2493                                    const register double tmp190_0 = A_12_5 + A_21_5;
2494                                    const register double tmp73_0 = A_02_1 + A_02_6;
2495                                    const register double tmp98_0 = A_01_0 + A_01_7 + A_10_3 + A_10_4;
2496                                    const register double tmp225_0 = A_12_4 + A_21_2;
2497                                    const register double tmp103_0 = A_02_4 + A_02_6;
2498                                    const register double tmp194_0 = A_02_0 + A_02_7 + A_20_0 + A_20_7;
2499                                    const register double tmp207_0 = A_12_0 + A_21_6;
2500                                    const register double tmp102_0 = A_20_5 + A_20_7;
2501                                    const register double tmp1_0 = A_22_3 + A_22_7;
2502                                    const register double tmp172_0 = A_10_1 + A_10_5;
2503                                    const register double tmp222_0 = A_12_5 + A_21_3;
2504                                    const register double tmp201_0 = A_02_2 + A_02_5 + A_20_2 + A_20_5;
2505                                    const register double tmp155_0 = A_12_4 + A_21_4;
2506                                    const register double tmp174_0 = A_02_1 + A_02_4 + A_20_1 + A_20_4;
2507                                    const register double tmp59_0 = A_01_0 + A_01_3;
2508                                    const register double tmp21_0 = A_20_2 + A_20_7;
2509                                    const register double tmp141_0 = A_02_2 + A_02_7 + A_20_2 + A_20_7;
2510                                    const register double tmp210_0 = A_01_1 + A_10_1;
2511                                    const register double tmp145_0 = A_00_0 + A_00_1;
2512                                    const register double tmp121_0 = A_12_0 + A_12_1 + A_21_6 + A_21_7;
2513                                    const register double tmp224_0 = A_12_3 + A_12_4 + A_21_2 + A_21_5;
2514                                    const register double tmp186_0 = A_02_2 + A_20_7;
2515                                    const register double tmp53_0 = A_11_4 + A_11_6;
2516                                    const register double tmp184_0 = A_02_5 + A_20_0;
2517                                    const register double tmp38_0 = A_12_0 + A_12_1;
2518                                    const register double tmp12_0 = A_01_1 + A_01_2 + A_01_5 + A_01_6 + A_10_1 + A_10_2 + A_10_5 + A_10_6;
2519                                    const register double tmp230_0 = A_12_6 + A_21_0;
2520                                    const register double tmp23_0 = A_11_4 + A_11_5 + A_11_6 + A_11_7;
2521                                    const register double tmp81_0 = A_20_1 + A_20_4;
2522                                    const register double tmp134_0 = A_10_3 + A_10_7;
2523                                    const register double tmp129_0 = A_21_0 + A_21_1;
2524                                    const register double tmp137_0 = A_01_0 + A_01_3 + A_01_4 + A_01_7;
2525                                    const register double tmp198_0 = A_01_0 + A_10_0;
2526                                    const register double tmp9_0 = A_21_1 + A_21_7;
2527                                    const register double tmp179_0 = A_01_0 + A_01_4;
2528                                    const register double tmp100_0 = A_20_1 + A_20_3 + A_20_4 + A_20_6;
2529                                    const register double tmp173_0 = A_02_0 + A_20_5;
2530                                    const register double tmp42_0 = A_21_0 + A_21_1 + A_21_6 + A_21_7;
2531                                    const register double tmp226_0 = A_12_3 + A_21_5;
2532                                    const register double tmp6_0 = A_22_0 + A_22_4;
2533                                    const register double tmp218_0 = A_12_1 + A_21_1;
2534                                    const register double tmp28_0 = A_01_2 + A_10_1;
2535                                    const register double tmp133_0 = A_02_6 + A_20_3;
2536                                    const register double tmp13_0 = A_00_2 + A_00_3 + A_00_6 + A_00_7;
2537                                    const register double tmp27_0 = A_12_2 + A_12_3 + A_12_4 + A_12_5;
2538                                    const register double tmp75_0 = A_10_1 + A_10_6;
2539                                    const register double tmp36_0 = A_01_0 + A_01_3 + A_10_0 + A_10_3;
2540                                    const register double tmp138_0 = A_10_0 + A_10_4;
2541                                    const register double tmp189_0 = A_12_2 + A_21_2;
2542                                    const register double tmp181_0 = A_02_7 + A_20_2;
2543                                    const register double tmp85_0 = A_02_1 + A_02_3 + A_20_4 + A_20_6;
2544                                    const register double tmp122_0 = A_01_1 + A_10_2;
2545                                    const register double tmp95_0 = A_01_3 + A_10_0;
2546                                    const register double tmp120_0 = A_12_6 + A_12_7 + A_21_0 + A_21_1;
2547                                    const register double tmp196_0 = A_02_0 + A_20_0;
2548                                    const register double tmp171_0 = A_02_3 + A_02_4;
2549                                    const register double tmp204_0 = A_12_1 + A_12_6 + A_21_1 + A_21_6;
2550                                    const register double tmp45_0 = A_10_1 + A_10_2;
2551                                    const register double tmp101_0 = A_01_5 + A_01_6 + A_10_5 + A_10_6;
2552                                    const register double tmp58_0 = A_11_0 + A_11_2 + A_11_5 + A_11_7;
2553                                    const register double tmp107_0 = A_20_3 + A_20_4;
2554                                    const register double tmp30_0 = A_01_1 + A_01_6 + A_10_2 + A_10_5;
2555                                    const register double tmp63_0 = A_12_2 + A_12_5;
2556                                    const register double tmp127_0 = A_12_2 + A_12_3;
2557                                    const register double tmp177_0 = A_02_2 + A_02_5 + A_20_0 + A_20_7;
2558                                    const register double tmp178_0 = A_10_0 + A_10_3 + A_10_4 + A_10_7;
2559                                    const register double tmp76_0 = A_01_1 + A_01_2;
2560                                    const register double tmp80_0 = A_22_2 + A_22_3 + A_22_6 + A_22_7;
2561                                    const register double tmp41_0 = A_12_6 + A_12_7;
2562                                    const register double tmp89_0 = A_01_0 + A_01_3 + A_01_4 + A_01_7 + A_10_0 + A_10_3 + A_10_4 + A_10_7;
2563                                    const register double tmp116_0 = A_02_1 + A_02_3 + A_02_4 + A_02_6 + A_20_1 + A_20_3 + A_20_4 + A_20_6;
2564                                    const register double tmp33_0 = A_22_0 + A_22_1 + A_22_2 + A_22_3 + A_22_4 + A_22_5 + A_22_6 + A_22_7;
2565                                    const register double tmp169_0 = A_21_3 + A_21_4;
2566                                    const register double tmp96_0 = A_20_0 + A_20_2;
2567                                    const register double tmp111_0 = A_12_3 + A_12_4;
2568                                    const register double tmp118_0 = A_20_2 + A_20_5;
2569                                    const register double tmp19_0 = A_12_3 + A_12_5;
2570                                    const register double tmp68_0 = A_01_5 + A_01_6;
2571                                    const register double tmp7_0 = A_11_1 + A_11_3 + A_11_5 + A_11_7;
2572                                    const register double tmp154_0 = A_12_3 + A_21_3;
2573                                    const register double tmp152_0 = A_02_4 + A_20_4;
2574                                    const register double tmp153_0 = A_02_3 + A_20_3;
2575                                    const register double tmp163_0 = A_02_5 + A_02_7 + A_20_5 + A_20_7;
2576                                    const register double tmp44_0 = A_01_4 + A_01_7;
2577                                    const register double tmp39_0 = A_02_1 + A_02_3 + A_02_4 + A_02_6;
2578                                    const register double tmp123_0 = A_21_2 + A_21_3 + A_21_4 + A_21_5;
2579                                    const register double tmp40_0 = A_02_5 + A_02_7;
2580                                    const register double tmp110_0 = A_02_0 + A_02_7;
2581                                    const register double tmp77_0 = A_12_2 + A_12_3 + A_21_2 + A_21_3;
2582                                    const register double tmp209_0 = A_12_7 + A_21_1;
2583                                    const register double tmp219_0 = A_02_4 + A_20_1;
2584                                    const register double tmp84_0 = A_01_1 + A_01_5 + A_10_2 + A_10_6;
2585                                    const register double tmp162_0 = A_12_1 + A_12_7 + A_21_1 + A_21_7;
2586                                    const register double tmp159_0 = A_01_3 + A_10_3;
2587                                    const register double tmp56_0 = A_11_1 + A_11_3;
2588                                    const register double tmp52_0 = A_01_2 + A_01_5;
2589                                    const register double tmp26_0 = A_00_4 + A_00_5 + A_00_6 + A_00_7;
2590                                    const register double tmp229_0 = A_12_0 + A_12_7 + A_21_1 + A_21_6;
2591                                    const register double tmp151_0 = A_10_2 + A_10_5;
2592                                    const register double tmp136_0 = A_02_0 + A_02_5 + A_20_0 + A_20_5;
2593                                    const register double tmp128_0 = A_21_6 + A_21_7;
2594                                    const register double tmp15_0 = A_12_2 + A_12_4;
2595                                    const register double tmp296_1 = tmp159_0*w42;
2596                                    const register double tmp130_1 = tmp67_0*w5;
2597                                    const register double tmp98_1 = A_01_6*w42;
2598                                    const register double tmp231_1 = tmp125_0*w6;
2599                                    const register double tmp42_1 = tmp34_0*w12;
2600                                    const register double tmp199_1 = A_02_5*w28;
2601                                    const register double tmp113_1 = tmp29_0*w13;
2602                                    const register double tmp330_1 = tmp152_0*w28;
2603                                    const register double tmp90_1 = A_01_1*w46;
2604                                    const register double tmp446_1 = tmp77_0*w22;
2605                                    const register double tmp108_1 = tmp43_0*w5;
2606                                    const register double tmp524_1 = A_12_6*w29;
2607                                    const register double tmp232_1 = tmp126_0*w34;
2608                                    const register double tmp33_1 = tmp25_0*w37;
2609                                    const register double tmp461_1 = tmp180_0*w1;
2610                                    const register double tmp14_1 = tmp8_0*w6;
2611                                    const register double tmp447_1 = tmp205_0*w26;
2612                                    const register double tmp452_1 = tmp198_0*w42;
2613                                    const register double tmp217_1 = tmp81_0*w9;
2614                                    const register double tmp76_1 = tmp59_0*w20;
2615                                    const register double tmp421_1 = tmp134_0*w31;
2616                                    const register double tmp485_1 = tmp51_0*w51;
2617                                    const register double tmp240_1 = tmp131_0*w1;
2618                                    const register double tmp160_1 = tmp91_0*w9;
2619                                    const register double tmp174_1 = A_20_1*w26;
2620                                    const register double tmp273_1 = A_10_1*w46;
2621                                    const register double tmp159_1 = tmp90_0*w47;
2622                                    const register double tmp228_1 = tmp103_0*w5;
2623                                    const register double tmp313_1 = tmp166_0*w45;
2624                                    const register double tmp45_1 = tmp37_0*w30;
2625                                    const register double tmp512_1 = tmp147_0*w13;
2626                                    const register double tmp73_1 = tmp56_0*w43;
2627                                    const register double tmp61_1 = A_01_6*w46;
2628                                    const register double tmp316_1 = tmp167_0*w43;
2629                                    const register double tmp189_1 = tmp112_0*w20;
2630                                    const register double tmp455_1 = tmp215_0*w39;
2631                                    const register double tmp360_1 = A_21_5*w24;
2632                                    const register double tmp258_1 = A_20_7*w2;
2633                                    const register double tmp196_1 = A_20_6*w26;
2634                                    const register double tmp37_1 = tmp29_0*w6;
2635                                    const register double tmp9_1 = A_12_7*w29;
2636                                    const register double tmp80_1 = tmp63_0*w19;
2637                                    const register double tmp312_1 = tmp165_0*w8;
2638                                    const register double tmp264_1 = tmp101_0*w1;
2639                                    const register double tmp124_1 = A_02_3*w26;
2640                                    const register double tmp229_1 = tmp123_0*w11;
2641                                    const register double tmp333_1 = tmp159_0*w46;
2642                                    const register double tmp533_1 = tmp222_0*w4;
2643                                    const register double tmp201_1 = tmp108_0*w37;
2644                                    const register double tmp444_1 = tmp35_0*w10;
2645                                    const register double tmp51_1 = tmp43_0*w18;
2646                                    const register double tmp214_1 = A_21_7*w29;
2647                                    const register double tmp518_1 = tmp86_0*w37;
2648                                    const register double tmp192_1 = tmp115_0*w5;
2649                                    const register double tmp355_1 = A_21_2*w27;
2650                                    const register double tmp156_1 = tmp87_0*w22;
2651                                    const register double tmp516_1 = tmp230_0*w27;
2652                                    const register double tmp366_1 = tmp104_0*w57;
2653                                    const register double tmp271_1 = tmp146_0*w49;
2654                                    const register double tmp437_1 = tmp218_0*w24;
2655                                    const register double tmp436_1 = tmp104_0*w54;
2656                                    const register double tmp167_1 = tmp98_0*w8;
2657                                    const register double tmp136_1 = tmp70_0*w34;
2658                                    const register double tmp406_1 = tmp207_0*w27;
2659                                    const register double tmp193_1 = tmp116_0*w12;
2660                                    const register double tmp486_1 = tmp225_0*w29;
2661                                    const register double tmp469_1 = tmp224_0*w11;
2662                                    const register double tmp287_1 = tmp71_0*w53;
2663                                    const register double tmp430_1 = tmp213_0*w28;
2664                                    const register double tmp462_1 = tmp220_0*w2;
2665                                    const register double tmp294_1 = tmp53_0*w59;
2666                                    const register double tmp218_1 = tmp118_0*w16;
2667                                    const register double tmp116_1 = tmp25_0*w31;
2668                                    const register double tmp495_1 = tmp76_0*w37;
2669                                    const register double tmp501_1 = tmp99_0*w46;
2670                                    const register double tmp0_1 = tmp0_0*w1;
2671                                    const register double tmp99_1 = tmp62_0*w17;
2672                                    const register double tmp429_1 = tmp212_0*w2;
2673                                    const register double tmp249_1 = tmp136_0*w9;
2674                                    const register double tmp504_1 = tmp229_0*w19;
2675                                    const register double tmp197_1 = A_12_2*w27;
2676                                    const register double tmp531_1 = tmp122_0*w35;
2677                                    const register double tmp265_1 = tmp142_0*w46;
2678                                    const register double tmp488_1 = tmp226_0*w4;
2679                                    const register double tmp528_1 = tmp115_0*w18;
2680                                    const register double tmp438_1 = tmp219_0*w2;
2681                                    const register double tmp233_1 = tmp127_0*w13;
2682                                    const register double tmp491_1 = tmp79_0*w1;
2683                                    const register double tmp215_1 = A_21_0*w4;
2684                                    const register double tmp24_1 = tmp18_0*w21;
2685                                    const register double tmp538_1 = tmp209_0*w27;
2686                                    const register double tmp379_1 = tmp167_0*w55;
2687                                    const register double tmp332_1 = tmp154_0*w4;
2688                                    const register double tmp498_1 = tmp68_0*w31;
2689                                    const register double tmp41_1 = tmp33_0*w33;
2690                                    const register double tmp464_1 = tmp179_0*w37;
2691                                    const register double tmp317_1 = tmp168_0*w40;
2692                                    const register double tmp378_1 = tmp106_0*w54;
2693                                    const register double tmp184_1 = tmp109_0*w14;
2694                                    const register double tmp292_1 = tmp14_0*w33;
2695                                    const register double tmp11_1 = tmp5_0*w11;
2696                                    const register double tmp354_1 = A_02_6*w26;
2697                                    const register double tmp84_1 = tmp37_0*w0;
2698                                    const register double tmp422_1 = tmp13_0*w30;
2699                                    const register double tmp132_1 = tmp69_0*w11;
2700                                    const register double tmp251_1 = tmp138_0*w31;
2701                                    const register double tmp18_1 = tmp12_0*w8;
2702                                    const register double tmp88_1 = A_21_1*w4;
2703                                    const register double tmp188_1 = A_12_2*w24;
2704                                    const register double tmp465_1 = tmp175_0*w31;
2705                                    const register double tmp235_1 = tmp128_0*w17;
2706                                    const register double tmp323_1 = A_02_1*w26;
2707                                    const register double tmp31_1 = tmp23_0*w38;
2708                                    const register double tmp397_1 = tmp170_0*w5;
2709                                    const register double tmp175_1 = tmp7_0*w3;
2710                                    const register double tmp148_1 = tmp81_0*w21;
2711                                    const register double tmp238_1 = tmp130_0*w19;
2712                                    const register double tmp59_1 = tmp46_0*w11;
2713                                    const register double tmp432_1 = tmp215_0*w35;
2714                                    const register double tmp398_1 = A_01_2*w46;
2715                                    const register double tmp497_1 = A_10_5*w46;
2716                                    const register double tmp28_1 = tmp21_0*w18;
2717                                    const register double tmp115_1 = tmp23_0*w32;
2718                                    const register double tmp441_1 = tmp23_0*w3;
2719                                    const register double tmp131_1 = tmp68_0*w37;
2720                                    const register double tmp289_1 = tmp155_0*w4;
2721                                    const register double tmp278_1 = tmp80_0*w44;
2722                                    const register double tmp5_1 = A_21_4*w27;
2723                                    const register double tmp254_1 = tmp140_0*w20;
2724                                    const register double tmp183_1 = tmp108_0*w31;
2725                                    const register double tmp279_1 = tmp151_0*w8;
2726                                    const register double tmp298_1 = tmp161_0*w16;
2727                                    const register double tmp505_1 = tmp230_0*w24;
2728                                    const register double tmp246_1 = tmp80_0*w52;
2729                                    const register double tmp100_1 = tmp53_0*w43;
2730                                    const register double tmp440_1 = tmp221_0*w16;
2731                                    const register double tmp481_1 = tmp188_0*w23;
2732                                    const register double tmp480_1 = tmp187_0*w35;
2733                                    const register double tmp384_1 = tmp150_0*w53;
2734                                    const register double tmp142_1 = tmp76_0*w31;
2735                                    const register double tmp372_1 = tmp191_0*w11;
2736                                    const register double tmp307_1 = A_10_7*w35;
2737                                    const register double tmp186_1 = tmp111_0*w19;
2738                                    const register double tmp127_1 = A_20_2*w2;
2739                                    const register double tmp391_1 = tmp167_0*w59;
2740                                    const register double tmp223_1 = tmp113_0*w20;
2741                                    const register double tmp454_1 = tmp197_0*w24;
2742                                    const register double tmp241_1 = tmp74_0*w51;
2743                                    const register double tmp529_1 = tmp114_0*w5;
2744                                    const register double tmp202_1 = tmp104_0*w7;
2745                                    const register double tmp236_1 = tmp96_0*w21;
2746                                    const register double tmp358_1 = tmp183_0*w11;
2747                                    const register double tmp102_1 = tmp51_0*w41;
2748                                    const register double tmp493_1 = A_20_5*w2;
2749                                    const register double tmp468_1 = tmp223_0*w4;
2750                                    const register double tmp435_1 = tmp217_0*w16;
2751                                    const register double tmp110_1 = tmp37_0*w36;
2752                                    const register double tmp479_1 = tmp189_0*w4;
2753                                    const register double tmp120_1 = tmp38_0*w22;
2754                                    const register double tmp16_1 = tmp10_0*w9;
2755                                    const register double tmp407_1 = tmp90_0*w53;
2756                                    const register double tmp442_1 = tmp66_0*w48;
2757                                    const register double tmp60_1 = A_10_4*w35;
2758                                    const register double tmp69_1 = tmp53_0*w45;
2759                                    const register double tmp144_1 = tmp77_0*w17;
2760                                    const register double tmp507_1 = tmp146_0*w48;
2761                                    const register double tmp424_1 = tmp174_0*w18;
2762                                    const register double tmp352_1 = tmp181_0*w23;
2763                                    const register double tmp451_1 = tmp199_0*w13;
2764                                    const register double tmp253_1 = tmp139_0*w16;
2765                                    const register double tmp353_1 = tmp182_0*w18;
2766                                    const register double tmp521_1 = tmp88_0*w22;
2767                                    const register double tmp346_1 = tmp175_0*w37;
2768                                    const register double tmp416_1 = tmp138_0*w37;
2769                                    const register double tmp324_1 = A_10_0*w35;
2770                                    const register double tmp152_1 = tmp84_0*w37;
2771                                    const register double tmp119_1 = tmp32_0*w21;
2772                                    const register double tmp86_1 = A_21_6*w29;
2773                                    const register double tmp290_1 = tmp156_0*w11;
2774                                    const register double tmp382_1 = tmp196_0*w26;
2775                                    const register double tmp91_1 = tmp49_0*w6;
2776                                    const register double tmp499_1 = A_10_2*w42;
2777                                    const register double tmp226_1 = tmp121_0*w13;
2778                                    const register double tmp477_1 = tmp195_0*w26;
2779                                    const register double tmp150_1 = A_02_4*w23;
2780                                    const register double tmp318_1 = tmp15_0*w22;
2781                                    const register double tmp396_1 = tmp206_0*w24;
2782                                    const register double tmp474_1 = A_02_0*w28;
2783                                    const register double tmp245_1 = tmp134_0*w37;
2784                                    const register double tmp3_1 = A_20_4*w26;
2785                                    const register double tmp44_1 = tmp36_0*w31;
2786                                    const register double tmp487_1 = tmp60_0*w52;
2787                                    const register double tmp293_1 = tmp158_0*w8;
2788                                    const register double tmp314_1 = A_01_2*w42;
2789                                    const register double tmp414_1 = tmp80_0*w51;
2790                                    const register double tmp472_1 = A_21_3*w27;
2791                                    const register double tmp321_1 = A_21_2*w24;
2792                                    const register double tmp225_1 = tmp120_0*w6;
2793                                    const register double tmp377_1 = tmp166_0*w59;
2794                                    const register double tmp413_1 = tmp186_0*w26;
2795                                    const register double tmp385_1 = tmp166_0*w55;
2796                                    const register double tmp310_1 = tmp164_0*w34;
2797                                    const register double tmp158_1 = tmp89_0*w34;
2798                                    const register double tmp449_1 = tmp203_0*w46;
2799                                    const register double tmp439_1 = tmp220_0*w28;
2800                                    const register double tmp22_1 = tmp16_0*w16;
2801                                    const register double tmp164_1 = tmp95_0*w46;
2802                                    const register double tmp417_1 = tmp74_0*w52;
2803                                    const register double tmp257_1 = tmp6_0*w25;
2804                                    const register double tmp203_1 = tmp18_0*w9;
2805                                    const register double tmp286_1 = tmp153_0*w28;
2806                                    const register double tmp155_1 = tmp33_0*w14;
2807                                    const register double tmp389_1 = tmp201_0*w12;
2808                                    const register double tmp508_1 = tmp145_0*w49;
2809                                    const register double tmp300_1 = tmp56_0*w55;
2810                                    const register double tmp299_1 = tmp162_0*w22;
2811                                    const register double tmp173_1 = tmp104_0*w25;
2812                                    const register double tmp32_1 = tmp24_0*w5;
2813                                    const register double tmp227_1 = tmp122_0*w39;
2814                                    const register double tmp484_1 = tmp3_0*w38;
2815                                    const register double tmp171_1 = tmp102_0*w21;
2816                                    const register double tmp478_1 = tmp190_0*w29;
2817                                    const register double tmp320_1 = tmp170_0*w18;
2818                                    const register double tmp327_1 = tmp6_0*w57;
2819                                    const register double tmp490_1 = tmp7_0*w32;
2820                                    const register double tmp419_1 = tmp127_0*w6;
2821                                    const register double tmp463_1 = tmp219_0*w28;
2822                                    const register double tmp12_1 = tmp6_0*w7;
2823                                    const register double tmp49_1 = tmp41_0*w22;
2824                                    const register double tmp344_1 = tmp173_0*w26;
2825                                    const register double tmp243_1 = tmp132_0*w2;
2826                                    const register double tmp83_1 = A_10_4*w39;
2827                                    const register double tmp297_1 = tmp160_0*w17;
2828                                    const register double tmp275_1 = tmp148_0*w34;
2829                                    const register double tmp168_1 = tmp99_0*w42;
2830                                    const register double tmp409_1 = tmp3_0*w32;
2831                                    const register double tmp1_1 = tmp1_0*w25;
2832                                    const register double tmp426_1 = tmp210_0*w39;
2833                                    const register double tmp375_1 = tmp109_0*w33;
2834                                    const register double tmp50_1 = tmp42_0*w19;
2835                                    const register double tmp513_1 = A_10_1*w42;
2836                                    const register double tmp97_1 = tmp45_0*w31;
2837                                    const register double tmp403_1 = tmp140_0*w1;
2838                                    const register double tmp71_1 = A_01_1*w42;
2839                                    const register double tmp520_1 = tmp84_0*w31;
2840                                    const register double tmp510_1 = A_10_6*w46;
2841                                    const register double tmp302_1 = A_10_0*w39;
2842                                    const register double tmp364_1 = tmp128_0*w22;
2843                                    const register double tmp515_1 = tmp142_0*w42;
2844                                    const register double tmp283_1 = tmp65_0*w56;
2845                                    const register double tmp222_1 = tmp112_0*w1;
2846                                    const register double tmp428_1 = tmp211_0*w27;
2847                                    const register double tmp371_1 = tmp190_0*w4;
2848                                    const register double tmp423_1 = tmp184_0*w23;
2849                                    const register double tmp276_1 = tmp149_0*w13;
2850                                    const register double tmp65_1 = tmp50_0*w9;
2851                                    const register double tmp305_1 = A_12_0*w29;
2852                                    const register double tmp170_1 = tmp101_0*w20;
2853                                    const register double tmp350_1 = tmp179_0*w31;
2854                                    const register double tmp466_1 = tmp172_0*w20;
2855                                    const register double tmp361_1 = tmp184_0*w26;
2856                                    const register double tmp431_1 = tmp214_0*w19;
2857                                    const register double tmp363_1 = tmp129_0*w17;
2858                                    const register double tmp178_1 = A_02_2*w28;
2859                                    const register double tmp527_1 = tmp120_0*w13;
2860                                    const register double tmp415_1 = tmp182_0*w5;
2861                                    const register double tmp450_1 = tmp200_0*w6;
2862                                    const register double tmp269_1 = A_01_7*w39;
2863                                    const register double tmp285_1 = tmp152_0*w2;
2864                                    const register double tmp272_1 = A_01_0*w35;
2865                                    const register double tmp339_1 = tmp136_0*w21;
2866                                    const register double tmp502_1 = tmp95_0*w42;
2867                                    const register double tmp38_1 = tmp30_0*w34;
2868                                    const register double tmp514_1 = tmp144_0*w46;
2869                                    const register double tmp96_1 = tmp56_0*w45;
2870                                    const register double tmp399_1 = tmp167_0*w45;
2871                                    const register double tmp483_1 = tmp173_0*w23;
2872                                    const register double tmp522_1 = tmp87_0*w17;
2873                                    const register double tmp519_1 = tmp91_0*w21;
2874                                    const register double tmp209_1 = A_12_5*w24;
2875                                    const register double tmp126_1 = tmp65_0*w48;
2876                                    const register double tmp367_1 = tmp187_0*w39;
2877                                    const register double tmp221_1 = tmp67_0*w18;
2878                                    const register double tmp381_1 = tmp146_0*w56;
2879                                    const register double tmp70_1 = tmp54_0*w31;
2880                                    const register double tmp216_1 = tmp117_0*w11;
2881                                    const register double tmp473_1 = A_02_7*w2;
2882                                    const register double tmp149_1 = tmp82_0*w22;
2883                                    const register double tmp357_1 = A_12_6*w4;
2884                                    const register double tmp534_1 = tmp226_0*w29;
2885                                    const register double tmp95_1 = tmp26_0*w15;
2886                                    const register double tmp500_1 = tmp64_0*w20;
2887                                    const register double tmp387_1 = tmp199_0*w6;
2888                                    const register double tmp471_1 = A_20_4*w23;
2889                                    const register double tmp281_1 = tmp74_0*w41;
2890                                    const register double tmp351_1 = tmp180_0*w20;
2891                                    const register double tmp63_1 = tmp48_0*w34;
2892                                    const register double tmp365_1 = tmp186_0*w23;
2893                                    const register double tmp448_1 = tmp206_0*w27;
2894                                    const register double tmp39_1 = tmp31_0*w13;
2895                                    const register double tmp453_1 = tmp196_0*w23;
2896                                    const register double tmp402_1 = tmp163_0*w18;
2897                                    const register double tmp137_1 = tmp71_0*w47;
2898                                    const register double tmp6_1 = A_02_0*w2;
2899                                    const register double tmp34_1 = tmp26_0*w36;
2900                                    const register double tmp383_1 = tmp197_0*w27;
2901                                    const register double tmp166_1 = tmp97_0*w12;
2902                                    const register double tmp114_1 = tmp40_0*w9;
2903                                    const register double tmp306_1 = A_12_7*w4;
2904                                    const register double tmp530_1 = tmp124_0*w39;
2905                                    const register double tmp388_1 = tmp200_0*w13;
2906                                    const register double tmp252_1 = tmp2_0*w30;
2907                                    const register double tmp210_1 = A_02_4*w26;
2908                                    const register double tmp200_1 = tmp21_0*w5;
2909                                    const register double tmp181_1 = tmp3_0*w10;
2910                                    const register double tmp425_1 = tmp106_0*w57;
2911                                    const register double tmp261_1 = A_21_7*w4;
2912                                    const register double tmp64_1 = tmp49_0*w13;
2913                                    const register double tmp506_1 = A_01_0*w39;
2914                                    const register double tmp457_1 = tmp213_0*w2;
2915                                    const register double tmp2_1 = tmp2_0*w0;
2916                                    const register double tmp393_1 = tmp203_0*w42;
2917                                    const register double tmp133_1 = A_01_3*w35;
2918                                    const register double tmp147_1 = tmp80_0*w41;
2919                                    const register double tmp8_1 = tmp4_0*w5;
2920                                    const register double tmp267_1 = tmp144_0*w42;
2921                                    const register double tmp17_1 = tmp11_0*w12;
2922                                    const register double tmp284_1 = tmp58_0*w50;
2923                                    const register double tmp328_1 = tmp66_0*w56;
2924                                    const register double tmp405_1 = tmp60_0*w51;
2925                                    const register double tmp467_1 = tmp222_0*w29;
2926                                    const register double tmp535_1 = tmp225_0*w4;
2927                                    const register double tmp356_1 = A_12_1*w29;
2928                                    const register double tmp274_1 = tmp147_0*w6;
2929                                    const register double tmp476_1 = tmp192_0*w39;
2930                                    const register double tmp206_1 = tmp10_0*w21;
2931                                    const register double tmp334_1 = tmp141_0*w9;
2932                                    const register double tmp482_1 = tmp181_0*w26;
2933                                    const register double tmp212_1 = A_20_7*w28;
2934                                    const register double tmp219_1 = tmp72_0*w21;
2935                                    const register double tmp47_1 = tmp39_0*w16;
2936                                    const register double tmp89_1 = A_10_3*w35;
2937                                    const register double tmp52_1 = tmp44_0*w1;
2938                                    const register double tmp492_1 = A_01_3*w39;
2939                                    const register double tmp81_1 = A_12_3*w24;
2940                                    const register double tmp77_1 = tmp60_0*w41;
2941                                    const register double tmp153_1 = tmp85_0*w21;
2942                                    const register double tmp304_1 = tmp163_0*w5;
2943                                    const register double tmp489_1 = tmp227_0*w11;
2944                                    const register double tmp107_1 = tmp35_0*w38;
2945                                    const register double tmp30_1 = tmp22_0*w39;
2946                                    const register double tmp260_1 = A_21_0*w29;
2947                                    const register double tmp343_1 = tmp172_0*w1;
2948                                    const register double tmp511_1 = tmp149_0*w6;
2949                                    const register double tmp139_1 = tmp73_0*w12;
2950                                    const register double tmp66_1 = tmp51_0*w44;
2951                                    const register double tmp208_1 = tmp4_0*w18;
2952                                    const register double tmp134_1 = tmp23_0*w10;
2953                                    const register double tmp205_1 = tmp105_0*w31;
2954                                    const register double tmp349_1 = tmp178_0*w8;
2955                                    const register double tmp341_1 = tmp53_0*w55;
2956                                    const register double tmp72_1 = tmp55_0*w17;
2957                                    const register double tmp79_1 = tmp62_0*w22;
2958                                    const register double tmp26_1 = tmp20_0*w19;
2959                                    const register double tmp141_1 = tmp75_0*w8;
2960                                    const register double tmp118_1 = tmp41_0*w17;
2961                                    const register double tmp259_1 = A_20_0*w28;
2962                                    const register double tmp458_1 = tmp212_0*w28;
2963                                    const register double tmp68_1 = tmp37_0*w15;
2964                                    const register double tmp154_1 = tmp86_0*w31;
2965                                    const register double tmp335_1 = tmp56_0*w59;
2966                                    const register double tmp359_1 = A_02_1*w23;
2967                                    const register double tmp56_1 = A_21_1*w29;
2968                                    const register double tmp392_1 = tmp145_0*w58;
2969                                    const register double tmp270_1 = tmp145_0*w48;
2970                                    const register double tmp92_1 = tmp47_0*w13;
2971                                    const register double tmp433_1 = tmp216_0*w34;
2972                                    const register double tmp420_1 = tmp125_0*w13;
2973                                    const register double tmp408_1 = tmp51_0*w52;
2974                                    const register double tmp494_1 = A_20_2*w28;
2975                                    const register double tmp362_1 = tmp185_0*w12;
2976                                    const register double tmp411_1 = tmp208_0*w19;
2977                                    const register double tmp336_1 = tmp65_0*w58;
2978                                    const register double tmp475_1 = A_21_4*w24;
2979                                    const register double tmp85_1 = A_12_3*w27;
2980                                    const register double tmp19_1 = tmp13_0*w15;
2981                                    const register double tmp537_1 = tmp132_0*w28;
2982                                    const register double tmp67_1 = tmp52_0*w8;
2983                                    const register double tmp459_1 = tmp210_0*w35;
2984                                    const register double tmp248_1 = tmp135_0*w34;
2985                                    const register double tmp326_1 = A_02_6*w23;
2986                                    const register double tmp23_1 = tmp17_0*w20;
2987                                    const register double tmp35_1 = tmp27_0*w11;
2988                                    const register double tmp62_1 = tmp47_0*w6;
2989                                    const register double tmp180_1 = tmp106_0*w7;
2990                                    const register double tmp277_1 = tmp150_0*w47;
2991                                    const register double tmp373_1 = tmp192_0*w35;
2992                                    const register double tmp337_1 = tmp157_0*w42;
2993                                    const register double tmp106_1 = tmp28_0*w39;
2994                                    const register double tmp369_1 = tmp168_0*w50;
2995                                    const register double tmp434_1 = tmp146_0*w58;
2996                                    const register double tmp331_1 = tmp155_0*w29;
2997                                    const register double tmp503_1 = tmp228_0*w27;
2998                                    const register double tmp93_1 = tmp61_0*w9;
2999                                    const register double tmp25_1 = tmp19_0*w22;
3000                                    const register double tmp146_1 = tmp79_0*w20;
3001                                    const register double tmp280_1 = A_10_6*w42;
3002                                    const register double tmp94_1 = tmp60_0*w44;
3003                                    const register double tmp400_1 = A_01_5*w42;
3004                                    const register double tmp151_1 = tmp83_0*w18;
3005                                    const register double tmp78_1 = tmp61_0*w21;
3006                                    const register double tmp301_1 = tmp6_0*w54;
3007                                    const register double tmp48_1 = tmp40_0*w21;
3008                                    const register double tmp75_1 = tmp58_0*w40;
3009                                    const register double tmp82_1 = tmp59_0*w1;
3010                                    const register double tmp74_1 = tmp57_0*w16;
3011                                    const register double tmp36_1 = tmp28_0*w35;
3012                                    const register double tmp370_1 = tmp189_0*w29;
3013                                    const register double tmp224_1 = tmp119_0*w19;
3014                                    const register double tmp109_1 = tmp36_0*w37;
3015                                    const register double tmp345_1 = tmp174_0*w5;
3016                                    const register double tmp101_1 = tmp44_0*w20;
3017                                    const register double tmp308_1 = A_01_5*w46;
3018                                    const register double tmp295_1 = tmp66_0*w58;
3019                                    const register double tmp117_1 = tmp26_0*w30;
3020                                    const register double tmp125_1 = tmp35_0*w3;
3021                                    const register double tmp309_1 = tmp9_0*w6;
3022                                    const register double tmp412_1 = tmp209_0*w24;
3023                                    const register double tmp46_1 = tmp38_0*w17;
3024                                    const register double tmp7_1 = A_02_7*w28;
3025                                    const register double tmp40_1 = tmp32_0*w9;
3026                                    const register double tmp386_1 = tmp198_0*w46;
3027                                    const register double tmp517_1 = tmp228_0*w24;
3028                                    const register double tmp532_1 = tmp223_0*w29;
3029                                    const register double tmp220_1 = A_02_3*w23;
3030                                    const register double tmp268_1 = tmp93_0*w20;
3031                                    const register double tmp322_1 = A_10_7*w39;
3032                                    const register double tmp311_1 = tmp8_0*w13;
3033                                    const register double tmp123_1 = A_01_4*w39;
3034                                    const register double tmp187_1 = A_20_6*w23;
3035                                    const register double tmp177_1 = A_02_5*w2;
3036                                    const register double tmp58_1 = A_21_6*w4;
3037                                    const register double tmp404_1 = tmp7_0*w38;
3038                                    const register double tmp122_1 = tmp64_0*w1;
3039                                    const register double tmp163_1 = tmp94_0*w5;
3040                                    const register double tmp15_1 = tmp9_0*w13;
3041                                    const register double tmp128_1 = A_20_5*w28;
3042                                    const register double tmp204_1 = tmp2_0*w15;
3043                                    const register double tmp539_1 = tmp207_0*w24;
3044                                    const register double tmp57_1 = tmp45_0*w37;
3045                                    const register double tmp53_1 = A_10_3*w39;
3046                                    const register double tmp157_1 = tmp88_0*w17;
3047                                    const register double tmp169_1 = tmp100_0*w16;
3048                                    const register double tmp162_1 = tmp93_0*w1;
3049                                    const register double tmp325_1 = tmp171_0*w12;
3050                                    const register double tmp179_1 = tmp105_0*w37;
3051                                    const register double tmp207_1 = A_20_1*w23;
3052                                    const register double tmp427_1 = tmp145_0*w56;
3053                                    const register double tmp368_1 = tmp188_0*w26;
3054                                    const register double tmp460_1 = tmp211_0*w24;
3055                                    const register double tmp347_1 = tmp176_0*w34;
3056                                    const register double tmp234_1 = tmp102_0*w9;
3057                                    const register double tmp21_1 = tmp15_0*w17;
3058                                    const register double tmp112_1 = tmp31_0*w6;
3059                                    const register double tmp319_1 = tmp169_0*w19;
3060                                    const register double tmp509_1 = A_01_7*w35;
3061                                    const register double tmp418_1 = tmp2_0*w36;
3062                                    const register double tmp266_1 = tmp143_0*w8;
3063                                    const register double tmp244_1 = tmp133_0*w28;
3064                                    const register double tmp138_1 = tmp72_0*w9;
3065                                    const register double tmp20_1 = tmp14_0*w14;
3066         &nb