~vcs-imports/escript-finley/trunk

        memcpy(tmpData,&(getDataAtOffsetRO(offset)),length*sizeof(double));

     }

  }

  // broadcast the data to all other processes

  MPI_Bcast( tmpData, length, MPI_DOUBLE, procNo, get_MPIComm() );

#endif

  {                             

    throw DataException("Can not integrate over non-continuous domains.");

  }

  dom->setToIntegrals(integrals_local,*this);

  // Global sum: use an array instead of a vector because elements of array are guaranteed to be contiguous in memory

  double *tmp = new double[dataPointSize];

        }

        else

        {

            return lazyAlgWorker<AbsMax>(0,MPI_MAX);

#else

            return lazyAlgWorker<AbsMax>(0);

        }

        else

        {

            return lazyAlgWorker<FMax>(numeric_limits<double>::max()*-1, MPI_MAX);

#else

            return lazyAlgWorker<FMax>(numeric_limits<double>::max()*-1);

        }

        else

        {

            return lazyAlgWorker<FMin>(numeric_limits<double>::max(), MPI_MIN);

#else

            return lazyAlgWorker<FMin>(numeric_limits<double>::max());

 

template <class BinaryOp>

double

Data::lazyAlgWorker(double init, MPI_Op mpiop_type)

#else

Data::lazyAlgWorker(double init)

        #pragma omp critical

        val=operation(val,localtot);

   }

   double globalValue;

   MPI_Allreduce( &localval, &globalValue, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD );

   if (globalValue!=0)

   {

        return makeNaN();

   }

   MPI_Allreduce( &val, &globalValue, 1, MPI_DOUBLE, mpiop_type, MPI_COMM_WORLD );

   return globalValue;

#else

  bool haveNaN=getReady()->hasNaN();

  double localValue=0;

  

  if (haveNaN)

  {

        localValue=1.0;

  AbsMax abs_max_func;

  localValue = algorithm(abs_max_func,0);

 

  

  MPI_Allreduce( &localValue, &globalValue, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD );

  return globalValue;

  bool haveNaN=getReady()->hasNaN();

  double localValue=0;

 

  if (haveNaN)

  {

        localValue=1.0;

  // set the initial maximum value to min possible double

  FMax fmax_func;

  localValue = algorithm(fmax_func,numeric_limits<double>::infinity()*-1);

  MPI_Allreduce( &localValue, &globalValue, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD );

  return globalValue;

#else

  bool haveNaN=getReady()->hasNaN();

  double localValue=0;

 

  if (haveNaN)

  {

        localValue=1.0;

  // set the initial minimum value to max possible double

  FMin fmin_func;

  localValue = algorithm(fmin_func,numeric_limits<double>::infinity());

  MPI_Allreduce( &localValue, &globalValue, 1, MPI_DOUBLE, MPI_MIN, MPI_COMM_WORLD );

  return globalValue;

#else

  int numDPPSample=temp.getNumDataPointsPerSample();

 

  double local_val, local_min;

  double next[2];

  #endif

  int local_lowi=0,local_lowj=0;        

    }

  }

 

  // determine the processor on which the minimum occurs

  next[0] = min;

  next[1] = numSamples;

  int numDPPSample=temp.getNumDataPointsPerSample();

 

  double local_val, local_max;

  double next[2];

  #endif

  int local_highi=0,local_highj=0;      

      highj=local_highj;

    }

  }

  // determine the processor on which the maximum occurs

  next[0] = max;

  next[1] = numSamples;

  Data out(0.,getDataPointShape(),getFunctionSpace());

  out.typeMatchRight(*this);

  int errcode=m_data->matrixInverse(out.getReadyPtr().get());

  int globalval=0;

  MPI_Allreduce( &errcode, &globalval, 1, MPI_INT, MPI_MAX, get_MPIComm() );

  errcode=globalval;

{

 

    int localNeedSummary=0;

    int globalNeedSummary=0;

#endif

    if (!m_data->isEmpty() &&

        localNeedSummary=1;

    }

 

    MPI_Allreduce( &localNeedSummary, &globalNeedSummary, 1, MPI_INT, MPI_MAX, get_MPIComm() );

    localNeedSummary=globalNeedSummary;

#endif

                  } // if (!error)

            }   // parallelised for

        } // if !haserror

        int rerror=0;

        MPI_Allreduce( &error, &rerror, 1, MPI_INT, MPI_MAX, get_MPIComm() );

        error=rerror;

            }  // if (!haserror)

        }       // parallel for

     } // !error

     int rerror=0;

     MPI_Allreduce( &error, &rerror, 1, MPI_INT, MPI_MAX, get_MPIComm() );

     error=rerror;

Data::get_MPISize() const

{

        int size;

        int error;

        error = MPI_Comm_size( get_MPIComm(), &size );

#else

Data::get_MPIRank() const

{

        int rank;

        int error;

        error = MPI_Comm_rank( get_MPIComm(), &rank );

#else

MPI_Comm

Data::get_MPIComm() const

{

        return MPI_COMM_WORLD;

#else

        return -1;

    {

        throw DataException("applyBinaryCFunction: Unsupported combination of inputs.");

    }

    int global;

    MPI_Allreduce(&err, &global, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);

    err=global;