void start_yoyo()
{ printf("Yo-Yo\n");
yo_tune();
init_velocity(); /* Needed by track */
sleep(1.0);
start_process(yoyo(yo_inches));
}
void test_mainRRR(void)
{
typedef CSimuStaticRod T;
CMeMaterialProperty mtl;
mtl.setYoung(2.00e5);
mtl.setPoisson(0.4);
mtl.setDamping(50.0, 0.0);
mtl.setMassDamping(1.0e-4);
int nv=2;
int nelm=1;
const double z1 = 0.02;
Vector3d pVertex[]={
Vector3d(2,0,0), Vector3d(3,0,0),
};
Vector3d init_velocity(0,0,0);
int element[4]={0,1, 2, 3};
const double rod_crossarea=1e-6;
T *s = new T(pVertex, nv, init_velocity, element, nelm, rod_crossarea, mtl);
//set constraints
int fixednodes[]={0};
const int len = sizeof(fixednodes)/sizeof(int);
CFixedPositionConstraint* fixpos = new CFixedPositionConstraint(10, 0, 1e10, len, fixednodes);
s->addConstraint(fixpos);
//s->setGravityAccelertion(Vector3d(0,-10,0));
{
int movenodes[]={1};
Vector3d vel(sqrt(2.0)-1, 0, -1); vel*=1e-3;
CVelocityConstraint *velo = new CVelocityConstraint(10, 1, 1000, 1, movenodes, vel);
//s->addConstraint(velo);
}
{
const Vector3d center=pVertex[0];
const Vector3d norm(0,1,0);
int vertbuffer[]={1};
const double av = PI*1.0*1e-3 *0.50;//0.25000;
CPlanarRotationConstraint *r = new CPlanarRotationConstraint(
10, 0, 1000,
1, vertbuffer,
center, norm, av);
s->addConstraint(r);
}
{
int fixednodes[]={1};
const int len = sizeof(fixednodes)/sizeof(int);
CFixedPositionConstraint* fixpos = new CFixedPositionConstraint(15, 1001, 1500, len, fixednodes);
//s->addConstraint(fixpos);
}
CSimuEngine e;
e.addSimuObject(s);
e.setTimestep(10.00e-5); // max step for verlet
e.startSimulationInMiliSeconds(10000, 50);
s->exportElementState(0, mtl, stdout);
}
void test_mainTET(void)
{
typedef CSimuStaticRod T;
CMeMaterialProperty mtl;
mtl.setYoung(3.00e5);
mtl.setPoisson(0.40);
mtl.setDamping(40.00, 0.0);
mtl.setMassDamping(1.0e-4);
int nv=4, nelm=6;
Vector3d pVertex[]={
Vector3d(0,0,0), Vector3d(1,0,0),
Vector3d(0,1,0), Vector3d(0,0,1),
};
Vector3d init_velocity(0,0,0);
int element[12]={3,0, 0,1, 1, 2, 2, 0, 3, 1, 3, 2};
const double rod_crossarea=1e-5;
T *s = new T(pVertex, nv, init_velocity, element, nelm, rod_crossarea, mtl);
//set constraints
int fixednodes[]={0,1, 2};
const int len = sizeof(fixednodes)/sizeof(int);
CFixedPositionConstraint* fixpos = new CFixedPositionConstraint(10, 0, 1e10, len, fixednodes);
s->addConstraint(fixpos);
s->setGravityAccelertion(Vector3d(0,0,0));
const double dx = 1;
const double dy = 0.0;
const double dz= 0.99;
{
int movenodes[]={3};
Vector3d vel(dx, dy, dz); vel*=1.00e-3;
CVelocityConstraint *velo = new CVelocityConstraint(10, 1, 1000, 1, movenodes, vel);
s->addConstraint(velo);
}
{
int movenodes[]={3};
Vector3d vel(-dx, -dy, -dz); vel*=1.000e-3;
CVelocityConstraint *velo = new CVelocityConstraint(20, 1001, 2000, 1, movenodes, vel);
//s->addConstraint(velo);
}
CSimuEngine e;
e.addSimuObject(s);
e.setTimestep(2.00e-4); // max step for verlet
const int timerid = 0;
startFastTimer(timerid);
e.startSimulationInMiliSeconds(10000, 50);
//e.startSimulation(100, 1);
stopFastTimer(timerid);
reportTimeDifference(timerid, "Hemi sphere simmu. run time:");
s->exportElementState(0, mtl, stdout);
//s->exportElementState(4, mtl, stdout);
//s->exportElementState(5, mtl, stdout);
}
//void test_main(void)
void test_mainTTTT(void)
{
CMeMaterialProperty mtl;
mtl.setYoung(4.0e4);
int nv, nelm, nface;
Vector3d* pVertex;
Vector3d init_velocity(0,0,0);
int *face, *element;
int nv_per_elm=4, meshtype;
const double thickness=0.001;
bool simLoadNeutralMeshFile(const char *fname,
Vector3d *& pVertex, int &nv,
int *& pFace, int &ntri,
int *& pTet, int &ntet, int &meshtype);
bool r = simLoadNeutralMeshFile("./cubemesh502.mesh", pVertex, nv, face, nface, element, nelm, meshtype);
CSimuSpringObj *ss = new CSimuSpringObj(
1, //springtype, 0: Vangalder, 1: Lloyd
pVertex, nv, //vertex array and length
init_velocity, //initial vertex velocity
1, //const int isSolid, //solid or surface 1: solid, 0: surface
&element[0], nv_per_elm, nelm, thickness, mtl);
CSimuSpringObj& s= *ss;
printf("Spring object spring count is %d\n", s.getElementCount());
//set constraints
CVertexConstraints constraints;
constraints.setFixedPositionXYZ();
int buffer[]={61, 169, 168, 3, 108, 104, 9, 111, 110, 0,
102, 107, 4, 105, 113,
6, 174, 106, 8, 180, 109, 10, 112, 176,
61, 177
};
for (int i=0; i<26; i++){
s.setConstraints(buffer[i], constraints);
}
s.setGravityAccelertion(Vector3d(0,-2,0));
//velocity verlet integration method
const double dt=0.0005; //1MS
CSimuEngine e;
e.addSimuObject(ss);
e.setTimestep(dt);
const int timerid = 0;
startFastTimer(timerid);
e.startSimulation(3000, 10);
stopFastTimer(timerid);
reportTimeDifference(timerid, "MASSSPRING. run time:");
}
void test_mainSSS(void)
{
CMeMaterialProperty mtl;
mtl.setYoung(2e4);
mtl.setMassDamping(5e-3);
mtl.m_rigid = 2;
mtl.setDamping(0.50, 0.50);
const int nv=6;
Vector3d pVertex[nv]={
Vector3d(0, 0, 0),
Vector3d(1, 0, 0),
Vector3d(0, 1, 0),
Vector3d(1, 1, 0),
Vector3d(0.5, 1.5, 0),
Vector3d(0.5, -0.5, 0)
};
Vector3d init_velocity(0,0,0);
const int nelm=4;
Vector3i element[nelm]={
Vector3i(0, 1, 3),
Vector3i(0, 3, 2),
Vector3i(2, 3, 4),
Vector3i(0, 5, 1)
};
const int nv_per_elm=3;
const double shell_thickness=0.001;
const int isstatic = 0;
typedef CSimuThinshell T;
T *pshell = new T(
pVertex, 6, //vertex array and length
init_velocity, //vertex velocity
&element[0].x, nv_per_elm, 4, //element information
shell_thickness,
mtl, //material property
isstatic
), &s = *pshell;
//set constraints
int fixednodes[]={0, 3};
const int len = sizeof(fixednodes)/sizeof(int);
CFixedPositionConstraint* fixpos = new CFixedPositionConstraint(10, 0, 1e10, len, fixednodes);
s.addConstraint(fixpos);
s.setGravityAccelertion(Vector3d(0,0,-10));
CSimuEngine e;
e.addSimuObject(pshell);
e.setTimestep(30e-3); //max step len for implicit
//e.setTimestep(70e-3); //max step len for explicit
e.startSimulation(10000, 50);
}
void test_mainxx(void)
{
CMeMaterialProperty mtl;
mtl.setYoung(1e9);
const int nv=24;
double pVertex[nv*3]={
-0.00000000033528,-0.00000000033528,0.00000000298023,
0.02999999966472,-0.00000000033528,0.00000000298023,
-0.00000000033528,0.02999999966472,0.00000000298023,
0.02999999966472,0.02999999966472,0.00000000298023,
-0.00000000033528,-0.00000000033528,0.03000000298023,
0.02999999966472,-0.00000000033528,0.03000000298023,
-0.00000000033528,0.02999999966472,0.03000000298023,
0.02999999966472,0.02999999966472,0.03000000298023,
-0.00000000033528,-0.00000000033528,0.06000000298023,
0.02999999966472,-0.00000000033528,0.06000000298023,
-0.00000000033528,0.02999999966472,0.06000000298023,
0.02999999966472,0.02999999966472,0.06000000298023,
-0.00000000033528,-0.00000000033528,0.09000000298023,
0.02999999966472,-0.00000000033528,0.09000000298023,
-0.00000000033528,0.02999999966472,0.09000000298023,
0.02999999966472,0.02999999966472,0.09000000298023,
-0.00000000033528,-0.00000000033528,0.12000000298023,
0.02999999966472,-0.00000000033528,0.12000000298023,
-0.00000000033528,0.02999999966472,0.12000000298023,
0.02999999966472,0.02999999966472,0.12000000298023,
-0.00000000033528,-0.00000000033528,0.15000000298023,
0.02999999966472,-0.00000000033528,0.15000000298023,
-0.00000000033528,0.02999999966472,0.15000000298023,
0.02999999966472,0.02999999966472,0.15000000298023
};
Vector3d init_velocity(0,0,0);
const int nelm=30;
int element[nelm*4]={
1,2,3,5,
5,6,2,3,
5,7,6,3,
2,4,3,6,
6,8,4,7,
3,4,7,6,
5,6,7,9,
9,10,6,7,
9,11,10,7,
6,8,7,10,
10,12,8,11,
7,8,11,10,
9,10,11,13,
13,14,10,11,
13,15,14,11,
10,12,11,14,
14,16,12,15,
11,12,15,14,
13,14,15,17,
17,18,14,15,
17,19,18,15,
14,16,15,18,
18,20,16,19,
15,16,19,18,
17,18,19,21,
21,22,18,19,
21,23,22,19,
18,20,19,22,
22,24,20,23,
19,20,23,22
};
for (int i=0; i<nelm*4; i++) element[i]--; //back from Fortran input.
CSimuTetra2* pshell = new CSimuTetra2(
(const Vector3d*)pVertex, nv, //vertex array and length
init_velocity, //vertex velocity
element, nelm, //element information
mtl //material property
);
CSimuTetra2& s = *pshell;
//set constraints
CVertexConstraints constraints;
constraints.setFixedPositionXYZ();
s.setConstraints(0, constraints);
s.setConstraints(1, constraints);
s.setConstraints(2, constraints);
s.setConstraints(3, constraints);
s.setGravityAccelertion(Vector3d(0,-2,0));
CSimuEngine e;
e.addSimuObject(pshell);
e.setTimestep(4.0e-4);
const int timerid = 0;
startFastTimer(timerid);
e.startSimulation(700);
stopFastTimer(timerid);
reportTimeDifference(timerid, "Plane simmu. run time:");
}
void test_mainPLATEQUAD(void) //PLATEQUAD
{
CMeMaterialProperty mtl;
mtl.setYoung(5.00e4);
mtl.setDamping(18, 0); //strain rate damping
mtl.setMassDamping(1.000e-4);
mtl.m_rigid = 1;
const int nv=18;
const double z0 = 0.1;
const double z1 = 0.00;
const double z2 = z0;
Vector3d pVertex[nv]={
Vector3d(0, 0, z0), //node 0
Vector3d(0.1, 0, z0),
Vector3d(0.2, 0, z0),
Vector3d(0.3, 0, z0),
Vector3d(0.4, 0, z0),
Vector3d(0.5, 0, z0),
Vector3d(0, 0.1, z1),
Vector3d(0.1, 0.1, z1),
Vector3d(0.2, 0.1, z1), //node 8
Vector3d(0.3, 0.1, z1),
Vector3d(0.4, 0.1, z1),
Vector3d(0.5, 0.1, z1),
Vector3d(0, 0.2, z2),
Vector3d(0.1, 0.2, z2),
Vector3d(0.2, 0.2, z2),
Vector3d(0.3, 0.2, z2),
Vector3d(0.4, 0.2, z2),
Vector3d(0.5, 0.2, z2),
};
Vector3d init_velocity(0,0,0);
const int nelm=10;
Vector4i element[nelm]={
Vector4i(0, 1, 7, 6),
Vector4i(1, 2, 8, 7),
Vector4i(2, 3, 9, 8),
Vector4i(3, 4, 10, 9),
Vector4i(4, 5, 11, 10),
Vector4i(6, 7, 13, 12),
Vector4i(7, 8, 14, 13),
Vector4i(8, 9, 15, 14),
Vector4i(9, 10, 16, 15),
Vector4i(10, 11, 17, 16)
};
const int nv_per_elm=4;
const double shell_thickness=0.004;
CSimuEngine e;
//typedef CSimuSpringThinshell T;
typedef CSimuThinshell T;
T *pshell;
{
pshell = new T(pVertex, nv, init_velocity, &element[0].x, nv_per_elm, nelm, shell_thickness, mtl);
//set constraints
int fixednodes[]={0, 6, 12, 1, 7, 13};
const int len = sizeof(fixednodes)/sizeof(int);
CFixedPositionConstraint* fixpos = new CFixedPositionConstraint(10, 0, 1e12, len, fixednodes);
T &s = *pshell;
s.addConstraint(fixpos);
s.setGravityAccelertion(Vector3d(0,0,-10));
e.addSimuObject(pshell);
}
{
CMeMaterialProperty mtl2 = mtl;
mtl2.setYoung(mtl.getYoung()*3.0);
for (int i=0; i<nv; i++) pVertex[i].z+=0.2;
T *pshell = new T(pVertex, nv, init_velocity, &element[0].x, nv_per_elm, nelm, shell_thickness, mtl2);
T &s = *pshell;
//set constraints
int fixednodes[]={0, 6, 12, 1, 7, 13};
const int len = sizeof(fixednodes)/sizeof(int);
CFixedPositionConstraint* fixpos = new CFixedPositionConstraint(10, 0, 1e12, len, fixednodes);
s.addConstraint(fixpos);
s.setGravityAccelertion(Vector3d(0,0,-10));
e.addSimuObject(pshell);
}
e.setTimestep(10.0e-4);
const int timerid = 0;
startFastTimer(timerid);
e.startSimulationInMiliSeconds(10000,100);
//int N=1000000;
//for (int i=0; i<N; i++)
// pshell->computeElasticForces(false);
stopFastTimer(timerid);
reportTimeDifference(timerid, "Plane quad simmu. run time:");
}
void test_mainPLATEPLATETRI(void) //PLATEPLATETRI
{
typedef CSimuThinshell T;
CMeMaterialProperty mtl;
mtl.setYoung(25.0e4);
mtl.setMassDamping(1e-4);
mtl.setDamping(10, 0); //strain rate damping
mtl.m_rigid = 0;
const int nv=18;
Vector3d pVertex[]={
Vector3d(0, 0, 0),
Vector3d(0.1, 0, 0),
Vector3d(0.2, 0, 0),
Vector3d(0.3, 0, 0),
Vector3d(0.4, 0, 0),
Vector3d(0.5, 0, 0),
Vector3d(0, 0.1, 0),
Vector3d(0.1, 0.1, 0),
Vector3d(0.2, 0.1, 0),
Vector3d(0.3, 0.1, 0),
Vector3d(0.4, 0.1, 0),
Vector3d(0.5, 0.1, 0),
Vector3d(0, 0.2, 0),
Vector3d(0.1, 0.2, 0),
Vector3d(0.2, 0.2, 0),
Vector3d(0.3, 0.2, 0),
Vector3d(0.4, 0.2, 0),
Vector3d(0.5, 0.2, 0),
};
Vector3d init_velocity(0,0,0);
const int nelm=20;
Vector3i element[]={
Vector3i(0, 1, 6),
Vector3i(6, 1, 7),
Vector3i(1, 2, 7),
Vector3i(7, 2, 8),
Vector3i(8, 2, 3),
Vector3i(8, 3, 9),
Vector3i(9, 3, 4),
Vector3i(9, 4, 10),
Vector3i(10, 4, 5),
Vector3i(10, 5, 11),//=============
Vector3i(12, 6, 13),
Vector3i(13, 6, 7),
Vector3i(13, 7, 14),
Vector3i(14, 7, 8),
Vector3i(14, 8, 15),
Vector3i(15, 8, 9),
Vector3i(15, 9, 16),
Vector3i(16, 9, 10),
Vector3i(16, 10, 17),
Vector3i(17, 10, 11)
};
const int nv_per_elm=3;
const double shell_thickness=0.001;
T *s = new T(
pVertex, nv, //vertex array and length
init_velocity, //vertex velocity
&element[0].x, nv_per_elm, nelm,//element information
shell_thickness,
mtl //material property
);
s->setGravityAccelertion(Vector3d(0, 0, -10));
//set constraints
int fixednodes[]={0, 6, 12, 1, 7, 13};
const int len = sizeof(fixednodes)/sizeof(int);
CFixedPositionConstraint* fixpos = new CFixedPositionConstraint(10, 0, 1e10, len, fixednodes);
s->addConstraint(fixpos);
CSimuEngine e;
e.addSimuObject(s);
e.setTimestep(10.0e-4);
//======================
const int timerid = 0;
startFastTimer(timerid);
e.startSimulation(20000,100);
stopFastTimer(timerid);
reportTimeDifference(timerid, "Plane simmu. run time:");
}
void test_main(void) //ShearRECT
{
typedef CSimuStaticRod T;
typedef CSimuThinshell T4;
CMeMaterialProperty mtl;
mtl.setYoung(2.00e5);
mtl.setPoisson(0.40);
mtl.setDamping(60.00, 0.0);
mtl.setMassDamping(1.0e-4);
T *s, *axisX, *axisY, *axisZ;
T4 *fplane;
{
int nv=2, nelm=1;
Vector3d pVertex[]={Vector3d(0,0,0), Vector3d(1,0,0)};
Vector3d init_velocity(0,0,0);
int element[2]={0,1};
const double rod_crossarea=1e-5;
//axisX = new T(pVertex, nv, init_velocity, element, nelm, rod_crossarea, mtl);
}
{//FLOOOR PLANE
int nv=4, nelm=1, nv_per_elm=4;
const double shell_thickness = 1;
Vector3d cc(0.5, -0.1, 0);
const double rr=5;
Vector3d pVertex[4]={
cc+Vector3d(-rr, 0, -rr),
cc+Vector3d(rr, 0, -rr),
cc+Vector3d(rr, 0, rr),
cc+Vector3d(-rr, 0, rr)
};
Vector3d init_velocity(0,0,0);
int element[4]={0,3, 2, 1};
fplane = new T4(pVertex, nv, init_velocity, &element[0], nv_per_elm, nelm, shell_thickness, mtl);
}
{
int nv=4, nelm=4;
Vector3d pVertex[]={
Vector3d(0,0,0), Vector3d(1,0,0),
Vector3d(0,1,0), Vector3d(1,1,0),
};
Vector3d init_velocity(0,0,0);
int element[8]={0,1, 0,2, 3, 2, 3, 1};
const double rod_crossarea=1e-5;
s = new T(pVertex, nv, init_velocity, element, nelm, rod_crossarea, mtl);
}
//set constraints
{//fixed pos.
int fixednodes[]={0,1};
const int len = sizeof(fixednodes)/sizeof(int);
CFixedPositionConstraint* fixpos = new CFixedPositionConstraint(10, 0, 1e10, len, fixednodes);
s->addConstraint(fixpos);
s->setGravityAccelertion(Vector3d(0,0,0));
}
{
const double dx = 0.0;
const double dy = -0.750;
const double dz= 0.0;
int movenodes[]={2, 3};
Vector3d vel(dx, dy, dz); vel*=1.00e-3*0.5;
CVelocityConstraint *velo = new CVelocityConstraint(10, 1, 2000, 2, movenodes, vel);
s->addConstraint(velo);
}
{
const double dx = 0.0;
const double dy = 0.70;
const double dz= 0.0;
int movenodes[]={2, 3};
Vector3d vel(dx, dy, dz); vel*=1.00e-3*0.5;
CVelocityConstraint *velo = new CVelocityConstraint(10, 5001, 7000, 2, movenodes, vel);
s->addConstraint(velo);
}
{
const double dx = 0.999;
const double dy = -0.999;
const double dz= 0;
int movenodes[]={2, 3};
Vector3d vel(dx, dy, dz); vel*=1.00e-3*0.3333;
CVelocityConstraint *velo = new CVelocityConstraint(10, 10001, 13000, 2, movenodes, vel);
s->addConstraint(velo);
}
{
const double dx = 0;
const double dy = -0.9999;
const double dz= -1.0;
int movenodes[]={2, 3};
Vector3d vel(dx, dy, dz); vel*=1.00e-3*0.33333;
CVelocityConstraint *velo = new CVelocityConstraint(10, 15001, 18000, 2, movenodes, vel);
s->addConstraint(velo);
}
CSimuEngine e;
e.addSimuObject(s);
e.addSimuObject(fplane);
e.setTimestep(5.00e-4); // max step for verlet
const int timerid = 0;
startFastTimer(timerid);
e.startSimulationInMiliSeconds(20000, 50);
//e.startSimulation(100, 1);
stopFastTimer(timerid);
reportTimeDifference(timerid, "Hemi sphere simmu. run time:");
s->exportElementState(0, mtl, stdout);
}
