libtrilinos-dev 10.4.0.dfsg-1ubuntu2 / usr / include / trilinos / HexBeam.hpp

This file is indexed.

/usr/include/trilinos/HexBeam.hpp is in libtrilinos-dev 10.4.0.dfsg-1ubuntu2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
/*--------------------------------------------------------------------*/
/*    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.                    */
/*--------------------------------------------------------------------*/

#ifndef _HexBeam_h_
#define _HexBeam_h_

#include <fei_base.hpp>

/**
HexBeam is a data generator used for testing the FEI. It generates data that
represents a cube of hex elements. More precisely, it's a cube that can be
elongated in one dimension, forming an arbitrarily long 3D bar. The dimensions
of the bar are WxWxD. In parallel runs, the bar is divided such that each
processor has roughly D/numprocs "slices" each with WxW elements.

The slices that are separated by processor boundaries share common nodes, which
are "shared nodes" in the global mesh.
 */
class HexBeam {
 public:
  enum { OneD = 0, TwoD = 1, ThreeD = 2 };

  HexBeam(int W, int D, int DofPerNode,
	  int decomp, int numProcs, int localProc);
  virtual ~HexBeam();

  virtual bool inErrorState() { return( inErrorState_ ); }

  virtual int numNodesPerElem() { return( nodesPerElem_ ); }

  virtual int numDofPerNode() { return( dofPerNode_ ); }

  virtual int numLocalElems() { return( localNumElems_ ); }

  virtual int numLocalNodes() { return( localNumNodes_ ); }

  virtual int firstLocalElem() { return( firstLocalElem_ ); }

  virtual int getElemConnectivity(int elemID, int* nodeIDs);

  virtual int getElemStiffnessMatrix(int elemID, double* elemMat);

  virtual int getElemLoadVector(int elemID, double* elemVec);

  virtual int getNumBCNodes();

  virtual int getBCNodes(int numNodes, int* nodeIDs);

  virtual int getBCValues(int numBCNodes, int* offsetsIntoField, double* vals);

  virtual int getNumSharedNodes();

  virtual int getSharedNodes(int numSharedNodes,
		     int*& sharedNodes,
		     int*& numSharingProcsPerNode,
		     int**& sharingProcs);

  virtual int getNumCRs() { return( 0 ); }

  virtual int getNumNodesPerCR() { return( 0 ); }

  virtual int getCRNodes(int** nodeIDs) { (void)nodeIDs; return(0); }

  int W_;
  int D_;
  int decomp_;
  int numProcs_;
  int localProc_;

  int totalNumElems_;
  int totalNumNodes_;
  int localNumElems_;
  int localNumNodes_;
  int firstLocalElem_;
  int firstLocalNode_;

  int numElemsPerSlice_;
  int numNodesPerSlice_;
  int numLocalSlices_;

  bool inErrorState_;

  int nodesPerElem_;
  int dofPerNode_;

  int numLocalDOF_;
  int numGlobalDOF_;
};

namespace HexBeam_Functions {

int init_elem_connectivities(FEI* fei, HexBeam& hexcube);

int init_shared_nodes(FEI* fei, HexBeam& hexcube);

int init_constraints(FEI* fei, HexBeam& hexcube, int& firstLocalCRID);

int load_elem_data(FEI* fei, HexBeam& hexcube);

int load_constraints(FEI* fei, HexBeam& hexcube, int firstLocalCRID);

int load_BC_data(FEI* fei, HexBeam& hexcube);

int print_cube_data(HexBeam& hexcube, int numProcs, int localProc);


int init_elem_connectivities(fei::MatrixGraph* matrixGraph, HexBeam& hexcube);

int init_shared_nodes(fei::MatrixGraph* matrixGraph, HexBeam& hexcube);

int init_constraints(fei::MatrixGraph* matrixGraph, HexBeam& hexcube,
		     int localProc, int& firstLocalCRID);

int init_slave_constraints(fei::MatrixGraph* matrixGraph, HexBeam& hexcube);

int load_elem_data(fei::MatrixGraph* matrixGraph,
		   fei::Matrix* mat,
		   fei::Vector* rhs,
		   HexBeam& hexcube);

int load_constraints(fei::LinearSystem* linSys, HexBeam& hexcube,
		     int firstLocalCRID);

int load_BC_data(fei::LinearSystem* linSys, HexBeam& hexcube);

}//namespace HexBeam_Functions

#endif // _HexBeam_h_

APT Browse - Built by Thomas Orozco.