SIM_Pebble/SIM_PBSolverProjectForces.cpp at master · iqch/SIM_Pebble · GitHub

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
134
135
136
137
/////////////////////////////////////////////////////
// PROJECT FORCES SOLVER

#include "include.h"

#include "SIM_Pebble.h"

#include "SIM_PBSolverProjectForces.h"

const SIM_DopDescription * SIM_PBSolverProjectForces::getDopDescription()
{
	static PRM_Template	 theTemplates[] = {

		PRM_Template(PRM_TOGGLE_J,			1, &theActivateName, PRMoneDefaults),
		PRM_Template(PRM_ALPHASTRING,	1, &theDataNameName, &theDataNameDef),

		PRM_Template() };

	static SIM_DopDescription	 theDopDescription(true, "sim_pb_forces", "Pebble Project Forces", "PBSolver_ProjectForces", classname(), theTemplates);
	return &theDopDescription;
}

SIM_Solver::SIM_Result SIM_PBSolverProjectForces::solveSingleObjectSubclass(SIM_Engine & engine, SIM_Object & object, SIM_ObjectArray & feedbacktoobjects, const SIM_Time & timestep, bool newobject)
{
	// PREPARE
	//bool activate = (getActivate() != 0);
	//if (!activate) return SIM_SOLVER_SUCCESS;

	UT_String dn = "";
	getDataName(dn);

	SIM_Data* isPebble = SIM_DATA_GET(object, "IsPebble", SIM_Data);
	if (isPebble == NULL) return SIM_SOLVER_SUCCESS;

	m_pebble = SIM_DATA_GET(object, dn, SIM_Pebble);
	if (m_pebble == NULL) return SIM_SOLVER_FAIL;
	for (Patch* _pb : m_pebble->m_P) if (_pb == NULL) return SIM_SOLVER_FAIL;

	m_object = &object;

	m_time = timestep;

	// COLLECT FORCES
	SIM_ConstDataArray F;

	object.filterConstSubData(F, NULL, SIM_DataFilterByType("SIM_Force"), SIM_FORCES_DATANAME, SIM_DataFilterNone());

	m_forces.clear();

	for (int i = 0; i < F.size(); i++)
	{
		const SIM_Force	*f = SIM_DATA_CASTCONST(F[i], SIM_Force);
		if (f == NULL) continue;

		m_forces.push_back(f);
	};

	//solve();

	solve(0, m_pebble->m_P.size());

	m_pebble->pubHandleModification();

	return SIM_SOLVER_SUCCESS;
};

void SIM_PBSolverProjectForces::solvePartial(const UT_JobInfo & info)
{
	int start, end;
	info.divideWork(m_pebble->m_P.size(), start, end);

	solve(start, end);
};

void SIM_PBSolverProjectForces::solve(int start, int end)
{
	UT_StringArray channels;
	channels.append("v");
	channels.append("force");
	channels.append("mass");

	for (int id = start; id < end; id++)
	{
		if (UTgetInterrupt()->opInterrupt()) break;

		Patch& pb = *m_pebble->m_P[id];

		pb.declarePages(channels);

		Page& P = pb.getPrimVar("P");

		Page& N = pb.getPrimVar("N");

		//Page& DPDU = pb.getPrimVar("dPdu");
		//Page& DPDV = pb.getPrimVar("dPdv");

		Page& MASS = pb.getPrimVar("mass");

		Page& V = pb.getPrimVar("v");
		V.m_projected = true;

		Page& force = pb.getPrimVar("force");
		force.m_projected = true;

		// EACH SAMPLE
		for (int i = 0; i < pb.dim[0]; i++)
		{
			for (int j = 0; j < pb.dim[1]; j++)
			{
				UT_Vector3 FF(0, 0, 0);

				UT_Vector3 nul(0, 0, 0), _F, _W;

				UT_Vector3 v = V.get(i, j);

				for (int fi = 0; fi < m_forces.size(); fi++)
				{
					const SIM_Force* f = m_forces[fi];

					f->getForce(*m_object, P.get(i, j), v, nul, 1.0, _F, _W);

					FF += _F;
				};

				UT_Vector3 F = pb.project(FF,i, j);
				force.get(i, j) = F;

				float mass = MASS.get(i, j)[0];
				if (mass == 0) continue;

				v += FF*m_time / mass;

				V.get(i, j) = pb.project(v, i, j);
			};
		};
	};
};