Function finiteDiffGenerator(Function& fcn, int ndir, void* user_data) {
// The step size to take
DMatrix eps = * reinterpret_cast<double *>(user_data);
// Obtain the symbols for nominal inputs/outputs
std::vector<MX> nominal_in = fcn.symbolicInput();
std::vector<MX> nominal_out = fcn.symbolicOutput();
// A growing list of inputs to the returned derivative function
std::vector<MX> der_ins = nominal_in;
der_ins.insert(der_ins.end(), nominal_out.begin(), nominal_out.end());
// A growing list of outputs to the returned derivative function
std::vector<MX> der_outs;
for (int k=0; k<ndir; ++k) {
std::vector<MX> seeds = fcn.symbolicInput();
std::vector<MX> perturbed_in(seeds.size());
for (int i=0; i<perturbed_in.size(); ++i) {
perturbed_in[i] = nominal_in[i] + eps*seeds[i];
}
std::vector<MX> perturbed_out = fcn(perturbed_in);
std::vector<MX> sens(perturbed_out.size());
for (int i=0; i<perturbed_out.size(); ++i) {
sens[i] = (perturbed_out[i]-nominal_out[i])/eps;
}
der_ins.insert(der_ins.end(), seeds.begin(), seeds.end());
der_outs.insert(der_outs.end(), sens.begin(), sens.end());
}
MXFunction ret("finite_diff", der_ins, der_outs);
return ret;
}
int main() {
Developers<double> sens("Front End Developer" , 99);
std::cout << sens.evaluate() << std::endl;
Developers<float> amanuel(".NET Developer", 50);
std::cout << amanuel.evaluate() << std::endl;
}
int MBSObjectFactory::AddSensor(int objectTypeId)
{
// the order of this list MUST coincide with the order in MBSObjectFactory()
switch(objectTypeId) //sensor type
{
case 1: //FieldVariableElementSensor
{
FieldVariableElementSensor sens(mbs);
sens.SetFVESPos3D(1,FieldVariableDescriptor(FieldVariableDescriptor::FVT_position, FieldVariableDescriptor::FVCI_x),Vector3D(0));
return GetMBS()->AddSensor(&sens);
}
case 2: //SpecialValueElementSensor
{
SingleElementDataSensor sens(mbs);
sens.SetSingleElementDataSensor(1,"");
return GetMBS()->AddSensor(&sens);
}
case 3: //LoadSensor
{
LoadSensor sens(mbs);
sens.SetLoadSensor(1);
return GetMBS()->AddSensor(&sens);
}
case 4: //MultipleSensor
{
TArray<int> sensors;
MultipleSensor sens(mbs);
sens.SetMultipleSensor(sensors,"maximum");
return GetMBS()->AddSensor(&sens);
}
case 5: //SystemSensor
{
SystemSensor sens(mbs);
sens.SetSystemSensor(SystemSensor::None);
return GetMBS()->AddSensor(&sens);
}
}
assert(0);
return -1;
}
void SWTrack::updateEvent(AMSEventR *event)
{
rEvent = event;
int mf0 = TrTrackR::DefaultFitID;
int mfit[NPAR] = { mf0, mf0 | TrTrackR::kFitLayer8,
mf0 | TrTrackR::kFitLayer9,
mf0 | TrTrackR::kFitLayer8 | TrTrackR::kFitLayer9 };
for (int i = 0; i < NLAY; i++) lyrSta[i] = 0;
for (int i = 0; i < NPAR; i++) fitPar[i] = 0;
TrTrackR *trk;
for (int t = tID; t >= 0; t--) {
trk = rEvent->pTrTrack(t);
if (trk) {
tID = t;
break;
}
}
if (!trk) return;
for (int i = 0; i < NPAR; i++)
if (trk->ParExists(mfit[i])) fitPar[i] = mfit[i];
if (fID < 0 || !trk->ParExists(mfit[fID])) {
for (int i = 0; i < NPAR; i++)
if (trk->ParExists(mfit[i])) {
fID = i;
break;
}
}
if (fID < 0) return;
for (int i = 0; i < trk->GetNhits(); i++) {
TrRecHitR *hit = trk->GetHit(i);
int ily = hit->GetLayer()-1;
if (hit->OnlyY()) lyrSta[ily] = LSTA_HITY;
else lyrSta[ily] = LSTA_HITT;
}
for (int i = 0; i < NLAY; i++) {
if (lyrSta[i] == 0) {
AMSPoint pnt;
AMSDir dir;
trk->Interpolate(TkDBc::Head->GetZlayer(i+1), pnt, dir);
TkSens sens(pnt, 0);
lyrSta[i] = sens.GetLadTkID();
}
}
}
void SWLadder::fillTrkVec()
{
nTrk = 0;
int layer = abs(tkID)/100;
for (int i = 0; rEvent && i < rEvent->nTrTrack(); i++) {
TrTrackR *trk = rEvent->pTrTrack(i);
if (!trk) continue;
int hid = -1;
for (int j = 0; j < trk->GetNhits(); j++) {
TrRecHitR *hit = trk->GetHit(j);
if (!hit) continue;
if (hit->GetLayer() == layer) {
hid = j;
if (hit->GetTkId() != tkID) continue;
for (int k = 0; k < drawObj.size(); k++) {
if ((drawObj[k].atrb & ATR_TRK) &&
rEvent->pTrRecHit(drawObj[k].idx) == hit)
drawObj[k].atrb |= ATR_TRID*(i+1);
}
}
}
if (hid >= 0) continue;
AMSPoint pnt;
AMSDir dir;
trk->Interpolate(TkDBc::Head->GetZlayer(layer), pnt, dir);
TkSens sens(pnt, 0);
if (sens.GetLadTkID() != tkID) continue;
double sax = TkDBc::Head->_ssize_active[0];
double say = TkDBc::Head->_ssize_active[1];
DrawObj dobj;
dobj.idx = i;
dobj.mult = sens.GetMultIndex();
dobj.col1 = Qt::yellow;
dobj.col2 = Qt::darkYellow;
dobj.atrb = ATR_TRK | ATR_TRID*(i+1);
dobj.x = SEN_SX*sens.GetSensCoo().x()/sax+SEN_DX*sens.GetSensor();;
dobj.y = SEN_SY-SEN_SY*sens.GetSensCoo().y()/say;
drawObj.push_back(dobj);
nTrk++;
}
}
void SWLadder::fillHitVec()
{
nHit = nHitT = nHitG = 0;
for (int i = 0; rEvent && i < rEvent->nTrRecHit(); i++) {
TrRecHitR *hit = rEvent->pTrRecHit(i);
if (!hit) continue;
if (hit->GetTkId() != tkID) continue;
nHit++;
DrawObj dobj;
int im1 = 0, im2 = hit->GetMultiplicity()-1;
dobj.idx = i;
dobj.col1 = Qt::magenta;
dobj.col2 = Qt::darkMagenta;
dobj.atrb = ATR_HIT;
if (hit->checkstatus(AMSDBc::USED)) {
nHitT++;
im1 = im2 = hit->GetResolvedMultiplicity();
dobj.col1 = Qt::yellow;
dobj.col2 = Qt::darkYellow;
dobj.atrb |= ATR_TRK;
}
else if (hit->OnlyY()) {
nHitG++;
continue;
}
double sax = TkDBc::Head->_ssize_active[0];
double say = TkDBc::Head->_ssize_active[1];
for (int j = im1; j <= im2; j++) {
AMSPoint coo = hit->GetCoord(j);
TkSens sens(coo, 0);
dobj.mult = j;
dobj.x = SEN_SX*sens.GetSensCoo().x()/sax+SEN_DX*sens.GetSensor();;
dobj.y = SEN_SY-SEN_SY*sens.GetSensCoo().y()/say;
drawObj.push_back(dobj);
}
}
}
const XC::Vector &XC::DispBeamColumn2d::getResistingForceSensitivity(int gradNumber)
{
const size_t numSections= getNumSections();
const Matrix &pts = quadRule.getIntegrPointCoords(numSections);
const Vector &wts = quadRule.getIntegrPointWeights(numSections);
double L = theCoordTransf->getInitialLength();
double oneOverL = 1.0/L;
// Zero for integration
q.Zero();
static XC::Vector qsens(3);
qsens.Zero();
// Some extra declarations
static XC::Matrix kbmine(3,3);
kbmine.Zero();
int j, k;
double d1oLdh = 0.0;
// Check if a nodal coordinate is random
bool randomNodeCoordinate = false;
static XC::ID nodeParameterID(2);
nodeParameterID(0) = theNodes[0]->getCrdsSensitivity();
nodeParameterID(1) = theNodes[1]->getCrdsSensitivity();
if(nodeParameterID(0) != 0 || nodeParameterID(1) != 0) {
randomNodeCoordinate = true;
const XC::Vector &ndICoords = theNodes[0]->getCrds();
const XC::Vector &ndJCoords = theNodes[1]->getCrds();
double dx = ndJCoords(0) - ndICoords(0);
double dy = ndJCoords(1) - ndICoords(1);
if(nodeParameterID(0) == 1) // here x1 is random
d1oLdh = dx/(L*L*L);
if(nodeParameterID(0) == 2) // here y1 is random
d1oLdh = dy/(L*L*L);
if(nodeParameterID(1) == 1) // here x2 is random
d1oLdh = -dx/(L*L*L);
if(nodeParameterID(1) == 2) // here y2 is random
d1oLdh = -dy/(L*L*L);
}
// Loop over the integration points
for(size_t i= 0; i < numSections; i++) {
int order = theSections[i]->getOrder();
const XC::ID &code = theSections[i]->getType();
double xi6 = 6.0*pts(i,0);
double wti = wts(i);
// Get section stress resultant gradient
const XC::Vector &s = theSections[i]->getStressResultant();
const XC::Vector &sens = theSections[i]->getStressResultantSensitivity(gradNumber,true);
// Perform numerical integration on internal force gradient
//q.addMatrixTransposeVector(1.0, *B, s, wts(i));
double si;
double sensi;
for(j = 0; j < order; j++) {
si = s(j)*wti;
sensi = sens(j)*wti;
switch(code(j)) {
case SECTION_RESPONSE_P:
q(0) += si;
qsens(0) += sensi;
break;
case SECTION_RESPONSE_MZ:
q(1) += (xi6-4.0)*si;
q(2) += (xi6-2.0)*si;
qsens(1) += (xi6-4.0)*sensi;
qsens(2) += (xi6-2.0)*sensi;
break;
default:
break;
}
}
if(randomNodeCoordinate) {
// Perform numerical integration to obtain basic stiffness matrix
//kb.addMatrixTripleProduct(1.0, *B, ks, wts(i)/L);
double tmp;
const XC::Matrix &ks = theSections[i]->getSectionTangent();
Matrix ka(workArea, order, 3);
ka.Zero();
for(j = 0; j < order; j++) {
switch(code(j)) {
case SECTION_RESPONSE_P:
for(k = 0; k < order; k++) {
ka(k,0) += ks(k,j)*wti;
}
break;
case SECTION_RESPONSE_MZ:
for(k = 0; k < order; k++) {
tmp = ks(k,j)*wti;
ka(k,1) += (xi6-4.0)*tmp;
ka(k,2) += (xi6-2.0)*tmp;
}
break;
default:
break;
}
}
for(j = 0; j < order; j++) {
switch (code(j)) {
case SECTION_RESPONSE_P:
for(k = 0; k < 3; k++) {
kbmine(0,k) += ka(j,k);
}
break;
case SECTION_RESPONSE_MZ:
for(k = 0; k < 3; k++) {
tmp = ka(j,k);
kbmine(1,k) += (xi6-4.0)*tmp;
kbmine(2,k) += (xi6-2.0)*tmp;
}
break;
default:
break;
}
}
}
}
static XC::Vector dqdh(3);
const XC::Vector &dAdh_u = theCoordTransf->getBasicTrialDispShapeSensitivity();
//dqdh = (1.0/L) * (kbmine * dAdh_u);
dqdh.addMatrixVector(0.0, kbmine, dAdh_u, oneOverL);
static XC::Vector dkbdh_v(3);
const XC::Vector &A_u = theCoordTransf->getBasicTrialDisp();
//dkbdh_v = (d1oLdh) * (kbmine * A_u);
dkbdh_v.addMatrixVector(0.0, kbmine, A_u, d1oLdh);
// Transform forces
static XC::Vector dummy(3); // No distributed loads
// Term 5
P = theCoordTransf->getGlobalResistingForce(qsens,dummy);
if(randomNodeCoordinate) {
// Term 1
P += theCoordTransf->getGlobalResistingForceShapeSensitivity(q,dummy);
// Term 2
P += theCoordTransf->getGlobalResistingForce(dqdh,dummy);
// Term 4
P += theCoordTransf->getGlobalResistingForce(dkbdh_v,dummy);
}
return P;
}
void main()
{ int i=0;
String cn="haarcascade_frontalface_alt.xml";
CascadeClassifier cd;
vector<Rect> faces;
bool cb=cd.load(cn);
Point cent;
bool lock=true;
int nodetect_cnt=0;
int clickdetectcnt=3;
bool quit=false;
try
{
VideoCapture cap(-1);
cap.set(CV_CAP_PROP_FRAME_WIDTH,320);
cap.set(CV_CAP_PROP_FRAME_HEIGHT,240);
if(!cap.isOpened()) {
std::cout<<"not found";
}
else{
voce::init("./lib", false, true, "./grammar", "digits");
std::cout<<"yeah";
}
std::cout<<cap.get(CV_CAP_PROP_FRAME_HEIGHT)<<"_________________"<<cap.get(CV_CAP_PROP_FRAME_WIDTH)<<std::endl;
for(;;)
{
//std::cout<<"yahan aaya ";
Mat frame;
rectval r1=sens();
cap >> frame;
ellipse( frame, frame_center(), Size(5,5), 0, 0, 360, Scalar( 255, 0, 255 ), 2, 8, 0 );
rectangle(frame,Point(r1.x,r1.y),Point(r1.x+r1.width,r1.y+r1.height),Scalar( 255, 0, 255 ));
cd.detectMultiScale(frame,faces);
for(int i=0 ; i<faces.size();i++){
Point center( faces[i].x + faces[i].width*0.5, faces[i].y + faces[i].height*0.5 );
cent=center;
if(lock==true)
convert(center);
ellipse( frame, center, Size( faces[i].width*0.5, faces[i].height*0.5), 0, 0, 360, Scalar( 255, 0, 255 ), 2, 8, 0 );
ellipse( frame, center, Size( 5, 5), 0, 0, 360, Scalar( 50, 205, 50 ), 2, 8, 0 );
}
imshow("edges", frame);
int c=waitKey(20);
if (voce::getRecognizerQueueSize() > 0)
{
std::string s = voce::popRecognizedString();
if (std::string::npos != s.rfind("stop"))
{
quit = true;
break;
}
std::string aopen="click",areset="center",apause="pause",aresume="resume",adblclick="double";
if(aopen.compare(s)==0){
sendEvent(1);
}
if(areset.compare(s)==0)
setCenter(cent.x,cent.y);
if(apause.compare(s)==0)
lock=false;
if(aresume.compare(s)==0)
lock=true;
if(adblclick.compare(s)==0)
sendEvent(2);
std::cout << "You said: " << s << std::endl;
//voce::synthesize(s);
}
//if(c==99)
if(c==27)
break;
if(c==108)
lock=false;
if(c==107)
lock=true;
//cout<<c;
}
voce::destroy();
}
catch( cv::Exception& e )
{
std::cout<< "---------"<<e.what();
}
//int a;
//std::cin>>a;
}
std::pair<unsigned int, Real>
EigenSystem::sensitivity_solve (const ParameterVector& parameters)
{
// make sure that eigensolution is already available
libmesh_assert(_n_converged_eigenpairs);
// the sensitivity is calculated based on the inner product of the left and
// right eigen vectors.
//
// y^T [A] x - lambda y^T [B] x = 0
// where y and x are the left and right eigenvectors
// d lambda/dp = (y^T (d[A]/dp - lambda d[B]/dp) x) / (y^T [B] x)
//
// the denominator remain constant for all sensitivity calculations.
//
std::vector<Number> denom(_n_converged_eigenpairs, 0.),
sens(_n_converged_eigenpairs, 0.);
std::pair<Real, Real> eig_val;
AutoPtr< NumericVector<Number> > x_right = NumericVector<Number>::build(this->comm()),
x_left = NumericVector<Number>::build(this->comm()),
tmp = NumericVector<Number>::build(this->comm());
x_right->init(*solution); x_left->init(*solution); tmp->init(*solution);
for (unsigned int i=0; i<_n_converged_eigenpairs; i++)
{
switch (_eigen_problem_type) {
case HEP:
// right and left eigenvectors are same
// imaginary part of eigenvector for real matrices is zero
this->eigen_solver->get_eigenpair(i, *x_right, NULL);
denom[i] = x_right->dot(*x_right); // x^H x
break;
case GHEP:
// imaginary part of eigenvector for real matrices is zero
this->eigen_solver->get_eigenpair(i, *x_right, NULL);
matrix_B->vector_mult(*tmp, *x_right);
denom[i] = x_right->dot(*tmp); // x^H B x
default:
// to be implemented for the non-Hermitian problems
libmesh_error();
break;
}
}
for (unsigned int p=0; p<parameters.size(); p++)
{
// calculate sensitivity of matrix quantities
this->assemble_eigensystem_sensitivity(parameters, p);
// now calculate sensitivity of each eigenvalue for the parameter
for (unsigned int i=0; i<_n_converged_eigenpairs; i++)
{
eig_val = this->eigen_solver->get_eigenpair(i, *x_right);
switch (_eigen_problem_type)
{
case HEP:
matrix_A->vector_mult(*tmp, *x_right);
sens[i] = x_right->dot(*tmp); // x^H A' x
sens[i] /= denom[i]; // x^H x
break;
case GHEP:
matrix_A->vector_mult(*tmp, *x_right);
sens[i] = x_right->dot(*tmp); // x^H A' x
matrix_B->vector_mult(*tmp, *x_right);
sens[i]-= eig_val.first * x_right->dot(*tmp); // - lambda x^H B' x
sens[i] /= denom[i]; // x^H B x
break;
default:
// to be implemented for the non-Hermitian problems
libmesh_error();
break;
}
}
}
return std::pair<unsigned int, Real> (0, 0.);
}
