int main(int argc, char *argv[])
/* error check, process command line input, and call getInvariants */
{
struct snpExceptions *exceptionList = NULL;
struct slName *chromList = NULL;
if (argc != 4)
{
usage();
return 1;
}
char *db= argv[1];;
exceptionList=getExceptionList(db, atoi(argv[2]));
chromList=getChromList(db);
getInvariants(db, exceptionList, chromList, argv[3]);
return 0;
}
void InvertibleHyperelasticMaterial::generateMatrixAndVirtualWorks(const Reference<Mesh> &mesh, const Reference<NodeIndexer> &indexer,
const FullOrderNonlinearMaterialCache &cahce, const SparseSymMatrixIndicesPerElementCache &matrixIndices, BlockedSymSpMatrix& matrix, Scalar *vws) const {
InvertibleHyperelasticElement *element = dynamic_cast<InvertibleHyperelasticElement *>(mesh->getMaterialElement(type));
const int elementCount = mesh->getElementCount();
const int nodePerElementCount = mesh->getNodePerElementCount();
const int drivativeEntry = element->getDirvateEntryCount();
const int deformGradientEntry = element->getDeformGradientsPreEntryCount();
const int quadratureCount = element->getQuadraturePointCount();
const int subMatrixEntryCount = ((3 * nodePerElementCount + 1) * 3 * nodePerElementCount) / 2;
const int workingEntryCount = subMatrixEntryCount + 3 * nodePerElementCount + (9 + 3 + 9 + 9 + 3 + 6 + 9) * quadratureCount;
Scalar *memory = new Scalar[workingEntryCount];
Initiation(memory, workingEntryCount);
Scalar *subMatrix = memory;
Scalar *subVirtualWorks = subMatrix + subMatrixEntryCount;
Scalar *gradients = subVirtualWorks + 3 * nodePerElementCount;
Scalar *diags = gradients + 9 * quadratureCount;
Scalar *leftOrthoMats = diags + 3 * quadratureCount;
Scalar *rightOrthoMats = leftOrthoMats + 9 * quadratureCount;
Scalar *energyGradient = rightOrthoMats + 9 * quadratureCount;
Scalar *energyHassian = energyGradient + 3 * quadratureCount;
Scalar *stresses = energyHassian + 6 * quadratureCount;
const Scalar *precomputes = (const Scalar *)cahce.getMemoryBlock();
const Scalar *shapeFunctionDrivativesPrecomputed = precomputes;
const Scalar *deformationGradientPrecomputed = precomputes + elementCount * drivativeEntry;
int *elementNodeIndices = (int *)alloca(3 * nodePerElementCount * sizeof(int));
for (int elementIndex = 0; elementIndex < elementCount; elementIndex++) {
element->setNodeIndices(elementIndex);
indexer->getElementNodesGlobalIndices(*element, nodePerElementCount, elementNodeIndices);
const Scalar *drivatePre = shapeFunctionDrivativesPrecomputed + elementIndex * drivativeEntry;
const Scalar *gradientPre = deformationGradientPrecomputed + elementIndex * deformGradientEntry;
element->generateDeformationGradient(gradientPre, gradients);
for (int quadrature = 0; quadrature < quadratureCount; quadrature++) {
modifiedDeformGradient(gradients + quadrature * 9, diags + quadrature * 3,
leftOrthoMats + quadrature * 3, rightOrthoMats + quadrature * 3);
Scalar invarients[3];
getInvariants(diags + quadrature * 3, invarients);
getEnergyGradient(invarients, energyGradient + 3 * quadrature);
getEnergyHassian(invarients, energyHassian + 6 * quadrature);
getPiolaKirchhoffStress(diags + quadrature * 3, leftOrthoMats + quadrature * 3, rightOrthoMats + quadrature * 3,
invarients, energyGradient + 3 * quadrature, stresses + 9 * quadrature);
}
//generate stifness matrix
Initiation(subMatrix, subMatrixEntryCount);
element->generateSubStiffnessMatrix(drivatePre, diags, leftOrthoMats, rightOrthoMats,
energyGradient, energyHassian, subMatrix);
//add matrix entries
int entryIndex = 0;
const int *localIndices = matrixIndices.getElementMatIndices(elementIndex);
for (int subCol = 0; subCol < nodePerElementCount * 3; subCol++) {
if (elementNodeIndices[subCol] >= 0) {
for (int subRow = subCol; subRow < nodePerElementCount * 3; subRow++) {
if (elementNodeIndices[subRow] >= 0)
matrix.addEntry(localIndices[entryIndex], subMatrix[entryIndex]);
entryIndex += 1;
}
}
else entryIndex += nodePerElementCount * 3 - subCol;
}
//generate virtual works
element->generateNodalVirtualWorks(drivatePre, stresses, subVirtualWorks);
for (int localIndex = 0; localIndex < nodePerElementCount * 3; localIndex++) {
int globalIndex = elementNodeIndices[localIndex];
if (globalIndex >= 0)
vws[globalIndex] += subVirtualWorks[localIndex];
}
}
delete element;
delete[] memory;
}
