void
FerroicModel<EvalT>::PostParseInitialize()
/******************************************************************************/
{
// create transitions
//
int nVariants = crystalVariants.size();
transitions.resize(nVariants*nVariants);
int transIndex = 0;
for(int I=0; I<nVariants; I++)
for(int J=0; J<nVariants; J++){
FM::Transition& t = transitions[transIndex];
// t.fromVariant = crystalVariants[I];
// t.toVariant = crystalVariants[J];
CrystalVariant& fromVariant = crystalVariants[I];
CrystalVariant& toVariant = crystalVariants[J];
t.transStrain = toVariant.spontStrain - fromVariant.spontStrain;
t.transEDisp = toVariant.spontEDisp - fromVariant.spontEDisp;
transIndex++;
}
// create/initialize transition matrix
//
int nTransitions = transitions.size();
aMatrix.resize(nVariants, nTransitions);
for(int I=0; I<nVariants; I++){
for(int J=0; J<nVariants; J++){
aMatrix(I,nVariants*I+J) = -1.0;
aMatrix(J,nVariants*I+J) = 1.0;
}
aMatrix(I,nVariants*I+I) = 0.0;
}
}
DLLEXPORT void vclGemm(const BlasTranspose transA, const BlasTranspose transB,
const int m, const int n, const int k,
const ScalarType alpha, const ScalarType a[], const int aOffset,
const ScalarType b[], const int bOffset,
const float beta, ScalarType c[], const int cOffset)
{
auto aPtr = &(a[0]) + aOffset;
auto bPtr = &(b[0]) + bOffset;
auto cPtr = &(c[0]) + cOffset;
int lda = transA == BlasTranspose::None ? m : k;
int ldb = transB == BlasTranspose::None ? k : n;
int aSize1 = (transA == BlasTranspose::Transpose) ? k : m;
int aSize2 = (transA == BlasTranspose::Transpose) ? m : k;
int bSize1 = (transB == BlasTranspose::Transpose) ? n : k;
int bSize2 = (transB == BlasTranspose::Transpose) ? k : n;
viennacl::matrix<ScalarType> aMatrix((ScalarType*)aPtr, viennacl::MAIN_MEMORY, aSize1, aSize2);
viennacl::matrix<ScalarType> bMatrix((ScalarType*)bPtr, viennacl::MAIN_MEMORY, bSize1, bSize2);
viennacl::matrix<ScalarType> cMatrix(cPtr, viennacl::MAIN_MEMORY, m, n);
};
DLLEXPORT void vclGemv(const BlasTranspose transA, const int m, const int n,
const ScalarType alpha, const ScalarType a[], const int aOffset, const int aLength,
const ScalarType x[], const int xOffset, const int xLength,
const ScalarType beta, ScalarType y[], const int yOffset)
{
auto aPtr = &(a[0]) + aOffset;
auto xPtr = &(x[0]) + xOffset;
auto yPtr = &(y[0]) + yOffset;
// wrap host buffer within ViennaCL
viennacl::vector<ScalarType> xVec((ScalarType*)xPtr, viennacl::MAIN_MEMORY, xLength);
viennacl::matrix<ScalarType> aMatrix((ScalarType*)aPtr, viennacl::MAIN_MEMORY, m, n);
viennacl::matrix<ScalarType> yMatrix(yPtr, viennacl::MAIN_MEMORY, m, n);
// auto aux = alpha * viennacl::linalg::prod(aMatrix, xVec) + beta * yMatrix;
};
