local void newrun(void) {
eps = getdparam("eps"); // get input parameters
dtime = getdparam("dtime");
nstatic = getiparam("nstatic");
#if !defined(QUICKSCAN)
theta = getdparam("theta");
#endif
usequad = getbparam("usequad");
tstop = getdparam("tstop");
dtout = getdparam("dtout");
options = getparam("options");
outputs = getparam("outputs");
if (! strnull(infile)) // if data file was given
inputdata(); // then read inital data
else { // else make initial data
nbody = getiparam("nbody"); // get number of bodies
// I added this
timesteps = getiparam("timesteps"); // get number of timesteps
init_random(getiparam("seed")); // set random number gen.
testdata(); // and make plummer model
}
rsize = 1.0; // start root w/ unit cube
nstep = 0; // begin counting steps
tout = tnow; // schedule first output
}
void test_large_dataset_write() {
hdf::HDFFile<> file("test.h5", hdf::HDFFile<>::truncate);
std::size_t nElements = 1ul << 31;
std::vector<hsize_t> dims;
dims.resize(2);
dims[1] = 3;
dims[0] = nElements;
hdf::Slab<2> filespace(dims);
auto dataset
= file.createDataset<int>("/test", filespace);
{
std::vector<int> testdata(nElements*3);
for (std::size_t i =0; i < nElements*3; ++i) {
testdata[i] = 1;
}
dataset->writeData(testdata);
}
std::vector<int> readData;
dataset->readData(readData);
assert(readData.size() == nElements*3);
assert(readData[0] == 1);
assert(readData[1] == 1);
assert(readData[2] == 1);
assert(readData[3] == 1);
}
static int CreatePack(lua_State *L, int arg, size_t alignment)
{
int err;
char *ptr;
int type = checktype(L, arg);
size_t n = toflattable(L, arg+1);
size_t size = n * sizeoftype(type);
if(size == 0)
return luaL_argerror(L, arg+1, errstring(ERR_LENGTH));
ptr = (char*)AlignedAlloc(alignment, size);
if(!ptr)
return luaL_error(L, "failed to allocate page aligned memory");
err = testdata(L, type, n, ptr, size);
if(err)
{
free(ptr);
return luaL_argerror(L, arg+1, errstring(err));
}
CreateAllocated(L, ptr, size);
return 1;
}
/**
* @brief Test for trivial only characters in string
* @param [in] Start - Start position in string
* @param [in] End - One character pass the end position of the string
* @param [in] filtercommentsset - For future use to determine trivial bytes
* @return Returns true if all characters are trivial
*/
static bool IsTrivialBytes(const char* Start, const char* End,
const FilterCommentsSet& filtercommentsset)
{
std::string testdata(Start, End);
//@TODO: Need to replace the following trivial string with a user specified string
size_t pos = testdata.find_first_not_of(" \t\r\n");
return (pos == std::string::npos);
}
TEST_F(Hdf5Test, WriteDataset) {
{
hdf::HDFFile<> file(file_name_, hdf::HDFFile<>::truncate);
std::vector<hsize_t> dims;
dims.resize(2);
dims[0] = 3;
dims[1] = 2;
hdf::Slab<2> filespace(dims);
auto datasetint = file.createDataset<
int>("/test", filespace);
}
hdf::HDFFile<> file(file_name_);
auto dataset = file.openDataset("/test");
std::vector<int> testdata(6);
testdata[0] = 1;
testdata[1] = 2;
testdata[2] = 3;
testdata[3] = 4;
testdata[4] = 5;
testdata[5] = 6;
dataset->writeData(testdata);
{
std::vector<hsize_t> dims;
dims.resize(2);
dims[0] = 2;
dims[1] = 3;
hdf::Slab<2> filespace(dims);
auto datasetint = file.createDataset<
int>("/test2", filespace);
datasetint->writeData(testdata);
std::vector<int> readData2;
datasetint->readData(readData2);
ASSERT_TRUE(readData2.size() == 6);
ASSERT_TRUE(readData2[0] == 1);
ASSERT_TRUE(readData2[1] == 2);
ASSERT_TRUE(readData2[2] == 3);
ASSERT_TRUE(readData2[3] == 4);
}
std::vector<int> readData;
dataset->readData(readData);
ASSERT_TRUE(readData.size() == 6);
ASSERT_TRUE(readData[0] == 1);
ASSERT_TRUE(readData[1] == 2);
ASSERT_TRUE(readData[2] == 3);
ASSERT_TRUE(readData[3] == 4);
}
static void TestFileSeek()
//
// Benchmark file seek method
//
{
ClearSessionDirectory();
test.Next(_L("RFile::Seek method"));
TInt increment=1789; // random number > cluster size
TInt count=0;
TInt pos=0;
// Create test file
TBuf8<1024> testdata(1024);
RFile f;
TInt r=f.Create(TheFs,_L("SEEKTEST"),EFileStream);
test_KErrNone(r);
count=64;
while (count--)
f.Write(testdata);
TInt fileSize=count*testdata.MaxLength();
pos=0;
count=0;
RTimer timer;
timer.CreateLocal();
TRequestStatus reqStat;
timer.After(reqStat,10000000); // After 10 secs
while(reqStat==KRequestPending)
{
TInt dum=(pos+=increment)%fileSize;
f.Seek(ESeekStart,dum);
count++;
}
test.Printf(_L("RFile::Seek operations in 10 secs == %d\n"),count);
timer.Close();
f.Close();
TheFs.Delete(_L("SEEKTEST"));
}
int main(int argc, char* argv[])
{
if (argc != 6){
cout<< "Usuage: 5 arguments, the 1. executable followded by 2. training set, 3. training label, \
4. test set, 5. tes label, 6. Number of Classe " << endl;
exit(1);
}
int nC = atoi(argv[5]);
cout<<"Number of Classe: " <<nC<<endl;
NBC nbc;
nbc.set_numClass(nC);
//Start get Input data
ifstream traindata(argv[1]);
ifstream trainlable(argv[2]);
ifstream testdata(argv[3]);
ifstream testlable(argv[4]);
if(trainlable.is_open() && traindata.is_open()){
string line, lable;
int l =-1;
while (!trainlable.eof()){
getline(traindata, line, '\n');
getline(trainlable, lable, '\n');
istringstream linestr(line);
vector<int> sample;
int v = 0;
if (lable.size() ==0 )
break;
l = atoi(lable.c_str());
//cout << "l: " <<l <<endl;
nbc.ltrain.push_back(l);
while(linestr >> v){
sample.push_back(v);
}
nbc.trainset.push_back(sample);
}
}
int test_Matrix::serialtest1()
{
fei::SharedPtr<testData> testdata(new testData(localProc_, numProcs_));
std::vector<int>& fieldIDs = testdata->fieldIDs;
std::vector<int>& fieldSizes = testdata->fieldSizes;
std::vector<int>& idTypes = testdata->idTypes;
std::vector<int>& ids = testdata->ids;
fei::SharedPtr<fei::VectorSpace> vspc(new fei::VectorSpace(comm_, "sU_Mat"));
vspc->defineFields(fieldIDs.size(),
&fieldIDs[0],
&fieldSizes[0]);
vspc->defineIDTypes(idTypes.size(), &idTypes[0]);
fei::SharedPtr<fei::MatrixGraph>
matgraph(new fei::MatrixGraph_Impl2(vspc, vspc, "sU_Mat"));
int numIDs = ids.size();
int fieldID = fieldIDs[0];
int idType = idTypes[0];
int patternID = matgraph->definePattern(numIDs, idType, fieldID);
CHK_ERR( matgraph->initConnectivityBlock(0, 1, patternID) );
CHK_ERR( matgraph->initConnectivity(0, 0, &ids[0]) );
CHK_ERR( matgraph->initComplete() );
fei::SharedPtr<fei::FillableMat> ssmat(new fei::FillableMat), ssmatT(new fei::FillableMat);
int localsize = matgraph->getRowSpace()->getNumIndices_Owned();
fei::SharedPtr<fei::Matrix> matrix(new fei::Matrix_Impl<fei::FillableMat>(ssmat, matgraph, localsize));
fei::SharedPtr<fei::Matrix> matrixT(new fei::Matrix_Impl<fei::FillableMat>(ssmatT, matgraph, localsize));
std::vector<int> indices(numIDs);
CHK_ERR( matgraph->getConnectivityIndices(0, 0, numIDs, &indices[0], numIDs) );
std::vector<double> data1(numIDs*numIDs);
std::vector<double*> data2d(numIDs);
int i;
for(i=0; i<numIDs; ++i) {
data2d[i] = &(data1[i*numIDs]);
}
for(i=0; i<numIDs*numIDs; ++i) {
data1[i] = 1.0*i;
}
CHK_ERR( matrix->sumIn(numIDs, &indices[0], numIDs, &indices[0],
&data2d[0], 0) );
CHK_ERR( matrix->sumIn(0, 0, &data2d[0], 0) );
CHK_ERR( matrixT->sumIn(numIDs, &indices[0],
numIDs, &indices[0], &data2d[0], 3) );
CHK_ERR( matrixT->sumIn(0, 0, &data2d[0], 3) );
if (*ssmat != *ssmatT) {
ERReturn(-1);
}
return(0);
}
startrun()
{
string restfile, contfile;
bool scanopt();
proc get_potential();
infile = getparam("in"); /* set I/O file names */
outfile = getparam("out");
restfile = getparam("restart");
contfile = getparam("continue");
savefile = getparam("save");
options = getparam("options"); /* set control options */
debug = getbparam("hdebug");
if (debug)
dprintf(0,"hdebug is turned on");
nrigid = getiparam("nrigid");
if (*contfile) /* resume interrupted run */
restorestate(contfile);
else if (*restfile) { /* resume w/ new parameters */
restorestate(restfile);
/* NOTE: someday, I will have a way to tell which, if any, of these *
* parameters are actually input from the command line, and only *
* change them. ANY NON-DEFAULT ARGS MUST BE SPECIFIED AT RESTART. */
eps = getdparam("eps"); /* get modified params */
tol = getdparam("tol");
options = getparam("options"); /* restorestate overwrite */
fcells = getdparam("fcells");
tstop = getdparam("tstop");
freqout = getdparam("freqout");
minor_freqout = getdparam("minor_freqout");
if (scanopt(options, "new_tout")) { /* reset output times? */
tout = tnow + 1 / freqout; /* offset from present */
minor_tout = tnow + 1 / minor_freqout;
}
} else { /* start new calculation */
if (*infile) /* was data file given? */
inputdata(infile); /* read inital data */
else { /* make initial conds? */
nbody = getiparam("nbody"); /* get nbody parameter */
if (nbody < 1) /* is value absurd? */
error("startrun: absurd nbody\n");
init_xrandom(getparam("seed")); /* set random generator */
testdata(getbparam("cencon")); /* make test model */
}
freq = getdparam("freq"); /* get various parameters */
eps = getdparam("eps");
tol = getdparam("tol");
fcells = getdparam("fcells");
tstop = getdparam("tstop");
freqout = getdparam("freqout");
minor_freqout = getdparam("minor_freqout");
nstep = 0; /* start counting steps */
minor_tout = tout = tnow; /* schedule first output */
SETVS(rmin, -2.0); /* init box scaling */
rsize = -2.0 * rmin[0];
}
contfile = getparam("potname");
if (*contfile) {
extpot = get_potential(contfile,
getparam("potpars"),getparam("potfile"));
}
}
int test_LinearSystem::test2()
{
#ifdef HAVE_FEI_AZTECOO
fei::SharedPtr<testData> testdata(new testData(localProc_, numProcs_));
std::vector<int>& fieldIDs = testdata->fieldIDs;
std::vector<int>& idTypes = testdata->idTypes;
std::vector<int>& ids = testdata->ids;
fei::SharedPtr<LinearSystemCore> az_lsc(new fei_trilinos::Aztec_LinSysCore(comm_));
char* param = new char[64];
sprintf(param,"debugOutput .");
CHK_ERR( az_lsc->parameters(1, ¶m) );
delete [] param;
fei::SharedPtr<fei::Factory> factory(new snl_fei::Factory(comm_, az_lsc));
fei::SharedPtr<fei::VectorSpace> vectorSpacePtr =
test_VectorSpace::create_VectorSpace(comm_,
testdata.get(), localProc_, numProcs_,
false, false, "U_LS2", factory);
fei::SharedPtr<fei::MatrixGraph> matrixGraphPtr =
test_MatrixGraph::create_MatrixGraph(testdata.get(), localProc_, numProcs_,
false, false, "U_LS2", vectorSpacePtr,
factory, path_);
std::vector<int> crIDTypes(2);
std::vector<int> crFieldIDs(2);
crIDTypes[0] = idTypes[0]; crIDTypes[1] = idTypes[0];
crFieldIDs[0] = fieldIDs[0]; crFieldIDs[1] = fieldIDs[0];
CHK_ERR( matrixGraphPtr->initLagrangeConstraint(0, idTypes[1],
2, //numIDs
&crIDTypes[0],
&(ids[1]),
&crFieldIDs[0]) );
CHK_ERR( matrixGraphPtr->initComplete() );
fei::SharedPtr<fei::Vector> vec_lsc = factory->createVector(vectorSpacePtr);
fei::SharedPtr<fei::Vector> vec_lsc2 = factory->createVector(vectorSpacePtr, true);
fei::SharedPtr<fei::Matrix> mat_lsc = factory->createMatrix(matrixGraphPtr);
fei::SharedPtr<fei::LinearSystem> linsys = factory->createLinearSystem(matrixGraphPtr);
linsys->setMatrix(mat_lsc);
linsys->setSolutionVector(vec_lsc2);
linsys->setRHS(vec_lsc);
int blockID=0;
int numIndices = matrixGraphPtr->getConnectivityNumIndices(blockID);
std::vector<int> indicesArray(numIndices);
int* indicesPtr = &indicesArray[0];
int checkNumIndices = 0;
CHK_ERR( matrixGraphPtr->getConnectivityIndices(blockID, 0,
numIndices, indicesPtr,
checkNumIndices) );
std::vector<double> data(ids.size(), 1.0);
double* dptr = &data[0];
std::vector<double*> coefPtrs(ids.size());
std::vector<double> crdata(2);
crdata[0] = 1.0;
crdata[1] = -1.0;
for(unsigned ii=0; ii<ids.size(); ++ii) coefPtrs[ii] = dptr;
CHK_ERR( mat_lsc->sumIn(numIndices, indicesPtr, numIndices, indicesPtr,
&coefPtrs[0]) );
CHK_ERR( vec_lsc->sumInFieldData(fieldIDs[0], idTypes[0],
ids.size(), &ids[0],
&data[0]) );
CHK_ERR( linsys->loadLagrangeConstraint(0, &crdata[0], 0.0) );
CHK_ERR( mat_lsc->gatherFromOverlap() );
CHK_ERR( az_lsc->matrixLoadComplete() );
CHK_ERR( linsys->loadComplete() );
std::vector<int> crindices;
linsys->getConstrainedEqns(crindices);
if (crindices.size() != 2) {
ERReturn(-7);
}
CHK_ERR( az_lsc->writeSystem("U_LS2") );
MPI_Barrier(comm_);
#endif
return(0);
}
void PlasmoidHandlerTest::cleanupTestCase()
{
QDir testdata(QStandardPaths::standardLocations(QStandardPaths::DataLocation).at(0));
testdata.removeRecursively();
}
int test_FEI_Impl::test2()
{
fei::SharedPtr<testData> testdata(new testData(localProc_, numProcs_));
fei::SharedPtr<FiniteElementData> fedata(new FEData(comm_));
fei::SharedPtr<LibraryWrapper> wrapper(new LibraryWrapper(fedata));
fei::SharedPtr<fei::FEI_Impl> fei(new fei::FEI_Impl(wrapper, comm_, 0));
std::string param0("name test1");
FEI_OSTRINGSTREAM osstr;
osstr << "debugOutput ";
if (path_.empty()) osstr << ".";
else osstr << path_;
std::string param1 = osstr.str();
int numParams = 2;
char** params = new char*[numParams];
params[0] = const_cast<char*>(param0.c_str());
params[1] = const_cast<char*>(param1.c_str());
//call the parameters function a couple of times to test the fei's internal
//method for merging string lists when parameters is called more than once.
CHK_ERR( fei->parameters(1, ¶ms[0]) );
CHK_ERR( fei->parameters(1, ¶ms[1]) );
CHK_ERR( fei->parameters(2, params) );
delete [] params;
CHK_ERR( fei->setIDLists(1, &(testdata->ids[0]),
1, &(testdata->ids[0])) );
CHK_ERR( fei->initFields(testdata->fieldIDs.size(),
&(testdata->fieldSizes[0]),
&(testdata->fieldIDs[0])) );
int numNodesPerElem = testdata->ids.size();
std::vector<int> numFieldsPerNode(numNodesPerElem, 1);
std::vector<int*>nodalFieldIDs(numNodesPerElem, &(testdata->fieldIDs[0]));
CHK_ERR( fei->initElemBlock(0, //blockID
1, //numElements
numNodesPerElem,
&numFieldsPerNode[0],
&nodalFieldIDs[0],
0, //numElemDofFieldsPerElement
NULL, //elemDofFieldIDs
0)); //interleaveStrategy
CHK_ERR( fei->initElem(0, //blockID
0, //elemID
&(testdata->ids[0])) );
std::vector<int*> sharingProcs2D(testdata->sharedIDs.size());
int i, offset = 0;
for(i=0; i<(int)testdata->numSharingProcsPerID.size(); ++i) {
sharingProcs2D[i] = &(testdata->sharingProcs[offset]);
offset += testdata->numSharingProcsPerID[i];
}
if (testdata->sharedIDs.size() > 0) {
CHK_ERR( fei->initSharedNodes(testdata->sharedIDs.size(),
&(testdata->sharedIDs[0]),
&(testdata->numSharingProcsPerID[0]),
&sharingProcs2D[0]) );
}
CHK_ERR( fei->initComplete() );
std::vector<double> rhsData(testdata->ids.size(), 1.0);
double one = 1.0;
CHK_ERR( fei->setMatScalars(1, &(testdata->ids[0]), &one) );
CHK_ERR( fei->setRHSScalars(1, &(testdata->ids[0]), &one) );
CHK_ERR( fei->setCurrentMatrix(testdata->ids[0]) );
CHK_ERR( fei->setCurrentRHS(testdata->ids[0]) );
int ii;
int numBCNodes = 2;
GlobalID* BCNodeIDs = &(testdata->ids[0]);
int BCFieldID = testdata->fieldIDs[0];
double* values = new double[numBCNodes];
int* offsetsIntoField = new int[numBCNodes];
for(ii=0; ii<numBCNodes; ++ii) {
values[ii] = 1.0;
offsetsIntoField[ii] = 0;
}
CHK_ERR( fei->loadNodeBCs(numBCNodes, BCNodeIDs, BCFieldID,
offsetsIntoField, values) );
delete [] values;
delete [] offsetsIntoField;
CHK_ERR( fei->loadComplete() );
int numActiveNodes = 0;
CHK_ERR( fei->getNumLocalNodes(numActiveNodes) );
if (numActiveNodes != (int)testdata->ids.size()) {
ERReturn(-1);
}
GlobalID* localNodes = new GlobalID[numActiveNodes];
CHK_ERR( fei->getLocalNodeIDList(numActiveNodes, localNodes, numActiveNodes) );
int totalFieldSize = 0;
for(ii=0; ii<(int)testdata->fieldSizes.size(); ++ii) {
totalFieldSize += testdata->fieldSizes[ii];
}
double* soln = new double[numActiveNodes*totalFieldSize];
int* offsets = new int[numActiveNodes+1];
CHK_ERR( fei->getNodalSolution(numActiveNodes, localNodes,
offsets, soln) );
delete [] offsets;
delete [] soln;
delete [] localNodes;
CHK_ERR( fei->resetInitialGuess() );
int fieldSize = 0;
CHK_ERR( fei->getFieldSize(testdata->fieldIDs[0], fieldSize) );
double initTime, loadTime, solveTime, solnReturnTime;
CHK_ERR( fei->cumulative_cpu_times(initTime, loadTime, solveTime,
solnReturnTime) );
return(0);
}
