FEData.hpp

#ifndef _FEData_h_
#define _FEData_h_

/*--------------------------------------------------------------------*/
/*    Copyright 2005 Sandia Corporation.                              */
/*    Under the terms of Contract DE-AC04-94AL85000, there is a       */
/*    non-exclusive license for use of this work by or on behalf      */
/*    of the U.S. Government.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/

#include <fei_iostream.hpp>
#include <fei_fstream.hpp>

#include <fei_mpi.h>

#define dbgOut() if (debugOutputLevel_ > 0) *dbgOStreamPtr_

#include <fei_defs.h>
#include <fei_FiniteElementData.hpp>

#include <snl_fei_Utils.hpp>

class FEData : public virtual FiniteElementData {
 public:
  FEData(MPI_Comm comm)
    :
    comm_(comm), numProcs_(1), localProc_(0),
    debugOutputLevel_(0),
    dbgPath_(NULL),
    dbgOStreamPtr_(NULL),
    dbgFileOpened_(false)
    {
#ifndef FEI_SER
      if (MPI_Comm_rank(comm_, &localProc_) != MPI_SUCCESS) MPI_Abort(comm_,-1);
      if (MPI_Comm_size(comm_, &numProcs_) != MPI_SUCCESS) MPI_Abort(comm_,-1);
#endif
      setDebugLog(0, ".");
    }

  virtual ~FEData()
    {
      if (dbgFileOpened_ == true) { dbgFStreamPtr_->close(); }

      delete [] dbgPath_;
      delete dbgOStreamPtr_;
    }

  int parameters(int numParams, char** params);

  int setLookup(Lookup& lookup)
    {
      dbgOut() << "setLookup" << FEI_ENDL;
      return(0);
    }


  int describeStructure(int numElemBlocks,
      const int* numElemsPerBlock,
      const int* numNodesPerElem,
      const int* elemMatrixSizePerBlock,
      int totalNumNodes,
      int numSharedNodes,
      int numMultCRs)
    {
      dbgOut() << "describeStructure" << FEI_ENDL
  << "   numElemBlocks: " << numElemBlocks << FEI_ENDL;
      for(int i=0; i<numElemBlocks; i++) {
  dbgOut() << "   elem-block " << i << ": " << FEI_ENDL
    << "      number of elements: " << numElemsPerBlock[i] << FEI_ENDL
    << "      nodes per element:  " << numNodesPerElem[i] << FEI_ENDL;
  dbgOut() << "         elemMatrixSizePerBlock: "
      << elemMatrixSizePerBlock[i] << FEI_ENDL;
      }
      return(0);
    }

   int setConnectivity(int elemBlockID,
           int elemID,
           int numNodes,
           const int* nodeNumbers,
           const int* numDofPerNode,
           const int* dof_ids)
     {
       dbgOut() << "setConnectivity" << FEI_ENDL
   << "   elemBlockID: " << elemBlockID << ", elemID: " << elemID 
    << ", numNodes: " << numNodes << FEI_ENDL
   << "   nodeNumbers: ";
       for(int i=0; i<numNodes; i++) {
   dbgOut() << nodeNumbers[i] << " ";
       }
       dbgOut() << FEI_ENDL;

       dbgOut() << "   numDOFPerNode: ";
       for(int j=0; j<numNodes; j++) {
   dbgOut() << numDofPerNode[j] << " ";
       }
       dbgOut() << FEI_ENDL;

       return(0);
     }


   int setElemMatrix(int elemBlockID,
         int elemID,
         int numNodes,
         const int* nodeNumbers,
         const int* dofPerNode,
         const int* dof_ids,
         const double *const * coefs)
     {
       dbgOut() << "setElemMatrix" << FEI_ENDL
   << "   elemBlockID: " << elemBlockID << ", elemID: " << elemID << FEI_ENDL
   << "   numNodes: " << numNodes << FEI_ENDL;
       int i;
       dbgOut() << "   nodeNumbers: ";
       for(i=0; i<numNodes; i++) {
   dbgOut() << nodeNumbers[i] << " ";
       }
       dbgOut() << FEI_ENDL << "   dofPerNode: ";
       int numRows = 0;
       for(i=0; i<numNodes; i++) {
   dbgOut() << dofPerNode[i] << " ";
   numRows += dofPerNode[i];
       }
       dbgOut() << FEI_ENDL << "   coefs:" << FEI_ENDL;
       for(i=0; i<numRows; i++) {
   dbgOut() << "      ";
   for(int j=0; j<numRows; j++) {
     dbgOut() << coefs[i][j] << " ";
   }
   dbgOut() << FEI_ENDL;
       }

       return(0);
     }


   int setElemVector(int elemBlockID,
         int elemID,
         int numNodes,
         const int* nodeNumbers,
         const int* dofPerNode,
         const int* dof_ids,
         const double* coefs)
     {
       dbgOut() << "setElemVector" << FEI_ENDL
   << "   elemBlockID: " << elemBlockID << ", elemID: " << elemID << FEI_ENDL
   << "   numNodes: " << numNodes << FEI_ENDL;
       int i;
       dbgOut() << "   nodeNumbers: ";
       for(i=0; i<numNodes; i++) {
   dbgOut() << nodeNumbers[i] << " ";
       }
       dbgOut() << FEI_ENDL << "   dofPerNode: ";
       int numRows = 0;
       for(i=0; i<numNodes; i++) {
   dbgOut() << dofPerNode[i] << " ";
   numRows += dofPerNode[i];
       }
       dbgOut() << FEI_ENDL << "   coefs:" << FEI_ENDL << "      ";
       for(i=0; i<numRows; i++) {
   dbgOut() << coefs[i] << " ";
       }
       dbgOut() << FEI_ENDL;
       return(0);
     }

   int setDirichletBCs(int numBCs,
           const int* nodeNumbers,
           const int* dofOffsets,
           const double* values)
     {
       dbgOut() << "setDirichletBCs" << FEI_ENDL
   << "   numBCs: " << numBCs << FEI_ENDL;
       for(int i=0; i<numBCs; i++) {
   dbgOut() << "     nodeNumber: " << nodeNumbers[i] << ", "
     << "dof-offset: " << dofOffsets[i] << ", value: " << values[i]<<FEI_ENDL;
       }

       return(0);
     }

   int sumIntoMatrix(int numRowNodes,
         const int* rowNodeNumbers,
         const int* rowDofOffsets,
         const int* numColNodesPerRow,
         const int* colNodeNumbers,
         const int* colDofOffsets,
         const double* coefs)
     {
       dbgOut() << "sumIntoMatrix, numRowNodes: " << numRowNodes << FEI_ENDL;
       int offset = 0;
       for(int i=0; i<numRowNodes; i++) {
   dbgOut() << "   rowNodeNumber " << rowNodeNumbers[i]
     << ", rowDofOffset " << rowDofOffsets[i] << FEI_ENDL;
   for(int j=0; j<numColNodesPerRow[i]; j++) {
     dbgOut() << "      colNodeNumber " << colNodeNumbers[offset]
        << ", colDofOffset " << colDofOffsets[offset]
        << ", value: " << coefs[offset]<<FEI_ENDL;
     offset++;
   }
       }

       return(0);
     }

   int sumIntoRHSVector(int numNodes,
         const int* nodeNumbers,
         const int* dofOffsets,
         const double* coefs)
     {
       dbgOut() << "sumIntoRHSVector, numNodes: " << numNodes << FEI_ENDL;
       for(int i=0; i<numNodes; i++) {
   dbgOut() << "   nodeNumber " << nodeNumbers[i]
     << ", dof-offset " << dofOffsets[i] << ", value: " << coefs[i]<<FEI_ENDL;
       }

       return(0);
     }

   int putIntoRHSVector(int numNodes,
         const int* nodeNumbers,
         const int* dofOffsets,
         const double* coefs)
     {
       dbgOut() << "putIntoRHSVector, numNodes: " << numNodes << FEI_ENDL;
       for(int i=0; i<numNodes; i++) {
   dbgOut() << "   nodeNumber " << nodeNumbers[i]
     << ", dof-offset " << dofOffsets[i] << ", value: " << coefs[i]<<FEI_ENDL;
       }

       return(0);
     }

   int loadComplete()
     {
       dbgOut() << "loadComplete" << FEI_ENDL;

       return(0);
     }

   int launchSolver(int& solveStatus, int& iterations)
     {
       dbgOut() << "launchSolver" << FEI_ENDL;

       solveStatus = 0;
       iterations = 0;

       return(0);
     }

   int reset()
     {
       dbgOut() << "reset" << FEI_ENDL;
       return(0);
     }

   int resetRHSVector()
     {
       dbgOut() << "resetRHSVector" << FEI_ENDL;
       return(0);
     }

   int resetMatrix()
     {
       dbgOut() << "resetMatrix" << FEI_ENDL;
       return(0);
     }

   int deleteConstraints()
     {
       dbgOut() << "deleteConstraints" << FEI_ENDL;
       return(0);
     }

   int getSolnEntry(int nodeNumber,
        int dofOffset,
        double& value)
     {
       dbgOut() << "getSolnEntry, nodeNumber: " << nodeNumber 
   << ", dofOffset: " << dofOffset << FEI_ENDL;

       value = -999.99;

       return(0);
    }

   int getMultiplierSoln(int CRID, double& lagrangeMultiplier)
     {
       lagrangeMultiplier = -999.99;
       return(0);
     }

   int putNodalFieldData(int fieldID,
       int fieldSize,
       int numNodes,
       const int* nodeNumbers,
       const double* coefs)
     {
       dbgOut() << "putNodalFieldData, fieldID: " << fieldID << ", fieldSize: "
   << fieldSize << FEI_ENDL;
       int offset = 0;
       for(int i=0; i<numNodes; i++) {
   dbgOut() << "   nodeNumber " << nodeNumbers[i] << ", coefs: ";
   for(int j=0; j<fieldSize; j++) {
     dbgOut() << coefs[offset++] << " ";
   }
   dbgOut() << FEI_ENDL;
       }
       
       return(0);
     }

   int setMultiplierCR(int CRID,
           int numNodes,
           const int* nodeNumbers,
           const int* dofOffsets,
           const double* coefWeights,
           double rhsValue)
     {
       dbgOut() << "setMultiplierCR, CRID: " << CRID << ", numNodes: " << numNodes << FEI_ENDL;
       for(int i=0; i<numNodes; i++) {
   dbgOut() << "   nodeNumber " << nodeNumbers[i] << ", dof-offset "
      << dofOffsets[i] << ", coefWeight: " << coefWeights[i] <<FEI_ENDL;
       }

       dbgOut() << "   rhsValue: " << rhsValue << FEI_ENDL;

       return(0);
     }

   int setPenaltyCR(int CRID,
        int numNodes,
        const int* nodeNumbers,
        const int* dofOffsets,
        const double* coefWeights,
        double penaltyValue,
        double rhsValue)
     {
       dbgOut() << "setPenaltyCR, CRID: " << CRID << ", numNodes: " << numNodes << FEI_ENDL;
       for(int i=0; i<numNodes; i++) {
   dbgOut() << "   nodeNumber " << nodeNumbers[i] << ", dof-offset "
      << dofOffsets[i] << ", coefWeight: " << coefWeights[i] <<FEI_ENDL;
       }

       dbgOut() << "   penaltyValue: " << penaltyValue << FEI_ENDL;
       dbgOut() << "   rhsValue: " << rhsValue << FEI_ENDL;

       return(0);
     }

 private:
   int setDebugLog(int debugOutputLevel, const char* path);

   MPI_Comm comm_;
   int numProcs_, localProc_;

   int debugOutputLevel_;
   char* dbgPath_;
   FEI_OSTREAM* dbgOStreamPtr_;
   bool dbgFileOpened_;
   FEI_OFSTREAM* dbgFStreamPtr_;
};

#endif // _FEData_h_