source: trunk/ADOL-C/examples/additional_examples/timing/vfunc_pargear.cpp

Last change on this file was 171, checked in by kulshres, 9 years ago

Squashed merge branch 'master' of 'gitclone' into svn

  • 'master' of 'gitclone': (84 commits) adjust example makefiles and include paths get rid of the symlink in the src subdirectory

details of the commits:
commit c9e4bc332d2363f737fc2e8a8fcfc2e43ddb9d15
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Oct 4 15:43:47 2010 +0200

adjust example makefiles and include paths

include paths in example sources were wrong for some time now
simplify makefile rules too, there is really no need for checking SPARSE
adjust include paths in makefiles.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit e6e1963e41e097fd5b4a79cd1611c12f6868dc94
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Oct 4 15:41:25 2010 +0200

get rid of the symlink in the src subdirectory

windows doesn't like symlinks and make infinite depth directories
we now create a symlink for build in the directory parallel to src
adjust all makefiles.am accordingly for build

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

  • Property svn:keywords set to Author Date Id Revision
File size: 22.3 KB
Line 
1/*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File:     vfunc_pargear.cpp
4 Revision: $Id: vfunc_pargear.cpp 171 2010-10-04 13:57:19Z stefan $
5 Contents: Example of function module containing the machine tool example
6           of gearing (parametrized version)
7 
8   Each << function module >> contains:
9         
10     (1) const char* const controlFileName
11     (2) int indepDim;
12     (3) int depDim;
13     (4) void initProblemParameters( void )
14     (5) void initIndependents( double* indeps )
15     (6) void originalVectorFunction( double* indeps, double* deps )
16     (7) void tapingVectorFunction( int tag, double* indeps, double* deps )   
17 
18 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
19               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel
20 
21 This file is part of ADOL-C. This software is provided as open source.
22 Any use, reproduction, or distribution of the software constitutes
23 recipient's acceptance of the terms of the accompanying license file.
24 
25---------------------------------------------------------------------------*/
26#define _VFUNC_PARGEAR_C_
27
28
29/****************************************************************************/
30/*                                                                 INCLUDES */
31#include <adolc/adolc.h>
32#include "rotations.h"
33
34#include <cmath>
35#include <time.h>
36#include <cstdlib>
37
38
39/****************************************************************************/
40/*                                                         GLOBAL VARIABLES */
41#define Pi 3.141592654
42
43/*--------------------------------------------------------------------------*/
44/*                                                        Control file name */
45const char* controlFileName = "pargearexam.ctrl";
46
47/*--------------------------------------------------------------------------*/
48/*                                                               Dimensions */
49int indepDim;
50int depDim;
51int radMotDegree;
52int verMotDegree;
53int horMotDegree;
54int helMotDegree;
55int angMotDegree;
56int modRolDegree;
57
58
59/*--------------------------------------------------------------------------*/
60/*                                        important machine tool parameters */
61// example bet06-23 convex pinion flank
62
63int konvex=     1;          // konvexe oder konkave Flanke
64int    zz=      6;          // Zaehnezahl
65
66double xmk=    -17.50195;   // Messerversatz
67double ymk=     80.0;       // MK-Versatz
68double kopspw=   0.0;       // Kopfspanwinkel
69double flaspw=   0.0;       // Flankenspanwinkel
70double meschw=   0.0;       // Messerschwenkwinkel
71double flkrrd= 101.44158;   // Spitzenradius, Flugkreisr.
72double e=        0.0;       // MK-Exzentrizitaet
73double exzenw=   0.0;       // Exzentrizitaetswinkel
74double thetas=   0.0;       // Messerkopfschwenkung
75double thetan=   0.0;       // Messerkopfneigung
76double xmw=     24.63350;   // MK-x
77double ymw=    -73.69500;   // MK-y
78double zmw=     96.15919;   // MK-z
79double thetaw=-314.52420;   // Wiegenwinkel=Waelztrommelwinkel
80double m=       0.0;        // Erzeugungs-Achsversatz
81double zwr=     0.0;        // Verschiebung Werkradachse
82double delta=   14.62090;   // Kegelwinkel
83double omega=   0.0;
84double c=       0.0;
85double r=        2.1;       // Kopfradius
86double rs=    2594.425;     // Sphaerikradius
87double ys=     876.147;     // Sphaerik-Mitte-Y
88double zs=   -2442.015;     // Sphaerik-Mitte-Z
89
90/*--------------------------------------------------------------------------*/
91/*                                       Other problem dependent parameters */
92//static unsigned short int dx[3]; /* variable needed by erand48(.) */
93
94
95/****************************************************************************/
96/*                                                  INIT PROBLEM PARAMETERS */
97void initProblemParameters( void ) {
98    fprintf(stdout,"PARGEAREXAM (ADOL-C Example)\n\n");
99
100    /* number of indeps & deps */
101    depDim   = 3;
102    indepDim = 3;
103
104    fprintf(stdout,"   Radial motion degree = ? [-1=no polynomial,0,...,6]");
105    fscanf(stdin,"%d",&radMotDegree);
106    fprintf(stdout,"\n");
107    if (radMotDegree>=0)
108        indepDim += radMotDegree + 1;
109
110    fprintf(stdout,"   Vertical motion degree = ? ");
111    fscanf(stdin,"%d",&verMotDegree);
112    fprintf(stdout,"\n");
113    if (verMotDegree>=0)
114        indepDim += verMotDegree + 1;
115
116    fprintf(stdout,"   Horizontal motion degree = ? ");
117    fscanf(stdin,"%d",&horMotDegree);
118    fprintf(stdout,"\n");
119    if (horMotDegree>=0)
120        indepDim += horMotDegree + 1;
121
122    fprintf(stdout,"   Helical motion degree = ? ");
123    fscanf(stdin,"%d",&helMotDegree);
124    fprintf(stdout,"\n");
125    if (helMotDegree>=0)
126        indepDim += helMotDegree + 1;
127
128    fprintf(stdout,"   Angular motion degree = ? ");
129    fscanf(stdin,"%d",&angMotDegree);
130    fprintf(stdout,"\n");
131    if (angMotDegree>=0)
132        indepDim += angMotDegree + 1;
133
134    fprintf(stdout,"   Modified roll degree = ? ");
135    fscanf(stdin,"%d",&modRolDegree);
136    fprintf(stdout,"\n");
137    if (modRolDegree>=0)
138        indepDim += modRolDegree + 1;
139
140    /* Init erand48(); */
141    struct tm s;
142    time_t t;
143    time(&t);
144    s=*localtime(&t);
145    srand(s.tm_sec*s.tm_min);
146    /*  dx[0]=rand();
147      dx[1]=rand();
148      dx[2]=rand();*/
149}
150
151
152/****************************************************************************/
153/*                                                        INITIALIZE INDEPs */
154void initIndependents( double* indeps ) {
155    for (int i=0; i<indepDim; i++)
156        indeps[i] = (double)rand();
157}
158
159
160
161/****************************************************************************/
162/*                                                 ORIGINAL SCALAR FUNCTION */
163
164/*--------------------------------------------------------------------------*/
165/*                                                       The model function */
166
167/*--------------------------------------------------------------------------*/
168// parametrized cutting edge
169void def_messer(
170    double * z,
171    double * messer,
172    // jetzt kommen die Parameter
173    double hgR,   // Kopfradius
174    double hgRs,  // Sphaerikradius
175    double hgYs,  // Sphaerik-Mitte-Y
176    double hgZs   // Sphaerik-Mitte-Z
177) {
178    double u0, uOri, phi0, h;
179
180    phi0= asin((hgR+hgYs)/(hgR+hgRs));
181    if (konvex==1) {
182        u0=hgRs*phi0;
183        uOri=1.0;
184    } else {
185        u0=hgRs*(phi0-Pi);
186        uOri=-1.0;
187    };
188
189    h= (z[0]-u0)/(uOri*hgRs);
190    messer[0]=hgZs+hgRs*cos(h);
191    messer[1]=0.0;
192    messer[2]=-hgYs-hgRs*sin(h);
193}
194
195/*--------------------------------------------------------------------------*/
196// the main function
197void gearFunction(
198    double* z,       // (u,v,t) Parametrisierung der Bewegung der Messerschneide
199    double* f,       // (x,y,z) Bewegte Messerschneide
200    // jetzt kommen die ganzen Parameter
201    double hgXmk,    // Messerversatz
202    double hgYmk,    // MK-Versatz
203    double hgKopSpW, // Kopfspanwinkel
204    double hgFlaSpW, // Flankenspanwinkel
205    double hgMeSchW, // Messerschwenkwinkel
206    double hgFlKrRd, // Flugkreisradius
207    double hgE,      // Exzentrizitaet
208    double hgExzenW, // Exzentrizitaetswinkel
209    double hgThetaS, // Messerkopfschwenkung
210    double hgThetaN, // Messerkopfneigung
211    double hgXmw,    // MK-x
212    double hgYmw,    // MK-y
213    double hgZmw,    // MK-z
214    double hgThetaW, // Wiegenwinkel
215    double hgM,      // Achsversatz
216    double hgZwr,    // Verschiebung Werkradachse
217    double hgDelta,  // Teilkegeloeffnungswinkel
218    double hgOmega,  //
219    double hgC,
220    double hgR,      // Kopfradius
221    double hgRs,     // Sphaerikradius
222    double hgYs,     // Sphaerik-Mitte-Y
223    double hgZs,     // Sphaerik-Mitte-Z
224    // jetzt die Zusatzbewegungen
225    int     radialMotionDegree,
226    double* radialMotionCoeff,
227    int     verticalMotionDegree,
228    double* verticalMotionCoeff,
229    int     horizontalMotionDegree,
230    double* horizontalMotionCoeff,
231    int     helicalMotionDegree,
232    double* helicalMotionCoeff,
233    int     angularMotionDegree,
234    double* angularMotionCoeff,
235    int     modifiedRollDegree,
236    double* modifiedRollCoeff
237) {
238    int i;
239    double ah;            // Hilfswert
240
241    // Definition der Schneide
242    def_messer(z,f,hgR,hgRs,hgYs,hgZs);
243
244    // Position der Schneide am Messerkopf
245    // (jetzt die Ber"ucksichtigung von hgKopSpW, hgFlaSpW, hgMeSchW)
246    D2T(f,hgMeSchW);     // Messerschwenkwinkel Theta_M
247    D3T(f,hgFlaSpW);     // Flankenspanwinkel Theta_F
248    D1(f,hgKopSpW);      // Kopfspanwinkel Theta_K
249    // Position der Schneide am Messerkopf
250    f[0] += hgFlKrRd;    // Flugkreisradius
251    f[1] -= hgXmk;       // Messerversatz
252
253    // Messerkopfrotation mit Parameter v
254    D3(f,z[1]);
255
256    // Lage des Messerkopfs auf der Wiege
257    f[2] -= hgYmk;
258
259    // Beruecksichtigung der Messerkopf-Exzentrizitaet
260    f[0] += hgE * cos(hgExzenW);
261    f[1] -= hgE * sin(hgExzenW);
262
263    // Eindrehen in Orientierung der Wiege
264    ah = f[0];
265    f[0] = f[1];
266    f[1] = ah;
267    f[2] = -f[2];
268
269    // Beruecksichtigung von Messerkopf-Schwenkwinkel hgThetaS
270    // und der Messerkopfneigung hgThetaN
271    D3T(f,hgThetaS);     // Einschwenken in die Neigungsachse
272    D1T(f,hgThetaN);     // Neigung um x-Achse
273    D3(f,hgThetaS);      // Rueckschwenken aus der Neigungsachse
274
275    // Verschiebung
276    f[0] -= hgXmw;       // FLB1-x-Achse zeigt nach oben     -> (-xNeu)
277    f[1] += hgZmw;       // FLB1-z-Achse zeigt nach rechts   ->  (yNeu)
278    f[2] += hgYmw;       // FLB1-y-Achse zeigt aus der Wiege ->  (zNeu)
279
280    // Wiegenwinkel thetaW, entspricht dem wert t=0
281    D3(f,hgThetaW);
282
283    // ZUSATZBEWEGUNG Radial motion
284    if (radialMotionDegree >= 0) {
285        ah = 0.0;
286        for (i=radialMotionDegree; i>0; i--) {
287            ah += radialMotionCoeff[i];
288            ah *= z[2];
289        }
290        ah += radialMotionCoeff[0];
291        f[1] += ah;        // radiale Verschiebung des Messerkopfes
292    }
293
294    // Wiegenbewegung mit Parameter t
295    D3(f,z[2]);
296
297    // ZUSATZBEWEGUNG Vertical motion
298    if (verticalMotionDegree >= 0) {
299        ah = 0.0;
300        for (i=verticalMotionDegree; i>0; i--) {
301            ah += verticalMotionCoeff[i];
302            ah *= z[2];
303        }
304        ah += verticalMotionCoeff[0];
305        f[0] += ah;        // Achsversatz in positive x-Richtung
306    }
307
308    // originaler Achsversatz
309    f[0] += hgM;
310
311    // ZUSATZBEWEGUNG Horizontal motion
312    if (horizontalMotionDegree >= 0) {
313        ah = 0.0;
314        for (i=horizontalMotionDegree; i>0; i--) {
315            ah += horizontalMotionCoeff[i];
316            ah *= z[2];
317        }
318        ah += horizontalMotionCoeff[0];
319        f[1] += ah;        // Achsversatz in positive y-Richtung
320    }
321
322    // ZUSATZBEWEGUNG Helical motion
323    if (helicalMotionDegree >= 0) {
324        ah = 0.0;
325        for (i=helicalMotionDegree; i>0; i--) {
326            ah += helicalMotionCoeff[i];
327            ah *= z[2];
328        }
329        ah += helicalMotionCoeff[0];
330        f[2] -= ah;        // Tiefenposition in negative z-Richtung
331    }
332
333    // Eindrehen in Orientierung des Werkrades
334    f[0] = -f[0];
335    ah = f[1];
336    f[1] = -f[2];
337    f[2] = -ah;
338
339    // ZUSATZBEWEGUNG Angular motion
340    if (angularMotionDegree >= 0) {
341        ah = 0.0;
342        for (i=angularMotionDegree; i>0; i--) {
343            ah += angularMotionCoeff[i];
344            ah *= z[2];
345        }
346        ah += angularMotionCoeff[0];
347        D1(f,ah);        // umgekehrte Drehung um die x-Achse
348    }
349
350    // Teilkegeloeffnungswinkel delta - y-Achsen entgegengesetzt
351    D1(f,hgDelta);
352
353    // neue Verschiebung der Werkradachse
354    f[2] += hgZwr; // z-Achse zeigt zu Spitze
355
356    // ZUSATZBEWEGUNG Modified roll
357    if (modifiedRollDegree >= 0) {
358        ah = 0.0;
359        for (i=modifiedRollDegree; i>1; i--) {
360            ah += modifiedRollCoeff[i];
361            ah *= z[2];
362        }
363        if (modifiedRollDegree > 0)
364            ah += modifiedRollCoeff[1];
365        ah += hgOmega;
366        ah *= z[2];
367        ah += modifiedRollCoeff[0];
368    } else {
369        ah = hgOmega;
370        ah *= z[2];
371    }
372    ah += hgC*z[1];   // c*v + omega * t
373    // gekoppelte Werkraddrehung in Abhaengigkeit von t und v
374    D3(f,ah);
375}
376
377/*--------------------------------------------------------------------------*/
378/*                                                   The interface function */
379void originalVectorFunction( double* indeps, double* deps ) {
380    int  i = 3;
381    double * radMotCoeff = indeps+i;
382    i += radMotDegree;
383    double * verMotCoeff = indeps+i;
384    i += verMotDegree;
385    double * horMotCoeff = indeps+i;
386    i += horMotDegree;
387    double * helMotCoeff = indeps+i;
388    i += helMotDegree;
389    double * angMotCoeff = indeps+i;
390    i += angMotDegree;
391    double * modRolCoeff = indeps+i;
392
393    gearFunction(
394        indeps,
395        deps,
396        // jetzt kommen die ganzen Parameter
397        xmk,    // Messerversatz
398        ymk,    // MK-Versatz
399        kopspw, // Kopfspanwinkel
400        flaspw, // Flankenspanwinkel
401        meschw, // Messerschwenkwinkel
402        flkrrd, // Flugkreisradius
403        e,      // Exzentrizitaet
404        exzenw, // Exzentrizitaetswinkel
405        thetas, // Messerkopfschwenkung
406        thetan, // Messerkopfneigung
407        xmw,    // MK-x
408        ymw,    // MK-y
409        zmw,    // MK-z
410        thetaw, // Wiegenwinkel
411        m,      // Achsversatz
412        zwr,    // Verschiebung Werkradachse
413        delta,  // Teilkegeloeffnungswinkel
414        omega,  //
415        c,
416        r,      // Kopfradius
417        rs,     // Sphaerikradius
418        ys,     // Sphaerik-Mitte-Y
419        zs,     // Sphaerik-Mitte-Z
420        // jetzt die Zusatzbewegungen
421        radMotDegree,
422        radMotCoeff,
423        verMotDegree,
424        verMotCoeff,
425        horMotDegree,
426        horMotCoeff,
427        helMotDegree,
428        helMotCoeff,
429        angMotDegree,
430        angMotCoeff,
431        modRolDegree,
432        modRolCoeff
433    );
434}
435
436
437/****************************************************************************/
438/*                                                   TAPING SCALAR FUNCTION */
439
440
441/*--------------------------------------------------------------------------*/
442/*                                                       The model function */
443
444/*--------------------------------------------------------------------------*/
445// parametrized cutting edge
446void def_messer(
447    adouble * z,
448    adouble * messer,
449    // jetzt kommen die Parameter
450    double hgR,   // Kopfradius
451    double hgRs,  // Sphaerikradius
452    double hgYs,  // Sphaerik-Mitte-Y
453    double hgZs   // Sphaerik-Mitte-Z
454) {
455    double u0, uOri, phi0;
456    adouble h;
457
458    phi0= asin((hgR+hgYs)/(hgR+hgRs));
459    if (konvex==1) {
460        u0=hgRs*phi0;
461        uOri=1.0;
462    } else {
463        u0=hgRs*(phi0-Pi);
464        uOri=-1.0;
465    };
466
467    h= (z[0]-u0)/(uOri*hgRs);
468    messer[0]=hgZs+hgRs*cos(h);
469    messer[1]=0.0;
470    messer[2]=-hgYs-hgRs*sin(h);
471}
472
473/*--------------------------------------------------------------------------*/
474// the main function
475void activeGearFunction(
476    adouble* z,      // (u,v,t) Parametrisierung der Bewegung der Messerschneide
477    adouble* f,      // (x,y,z) Bewegte Messerschneide
478    // jetzt kommen die ganzen Parameter
479    double hgXmk,    // Messerversatz
480    double hgYmk,    // MK-Versatz
481    double hgKopSpW, // Kopfspanwinkel
482    double hgFlaSpW, // Flankenspanwinkel
483    double hgMeSchW, // Messerschwenkwinkel
484    double hgFlKrRd, // Flugkreisradius
485    double hgE,      // Exzentrizitaet
486    double hgExzenW, // Exzentrizitaetswinkel
487    double hgThetaS, // Messerkopfschwenkung
488    double hgThetaN, // Messerkopfneigung
489    double hgXmw,    // MK-x
490    double hgYmw,    // MK-y
491    double hgZmw,    // MK-z
492    double hgThetaW, // Wiegenwinkel
493    double hgM,      // Achsversatz
494    double hgZwr,    // Verschiebung Werkradachse
495    double hgDelta,  // Teilkegeloeffnungswinkel
496    double hgOmega,  //
497    double hgC,
498    double hgR,      // Kopfradius
499    double hgRs,     // Sphaerikradius
500    double hgYs,     // Sphaerik-Mitte-Y
501    double hgZs,     // Sphaerik-Mitte-Z
502    // jetzt die Zusatzbewegungen
503    int     radialMotionDegree,
504    adouble* radialMotionCoeff,
505    int     verticalMotionDegree,
506    adouble* verticalMotionCoeff,
507    int     horizontalMotionDegree,
508    adouble* horizontalMotionCoeff,
509    int     helicalMotionDegree,
510    adouble* helicalMotionCoeff,
511    int     angularMotionDegree,
512    adouble* angularMotionCoeff,
513    int     modifiedRollDegree,
514    adouble* modifiedRollCoeff
515) {
516    int i;
517    adouble ah;
518
519    // Definition der Schneide
520    def_messer(z,f,hgR,hgRs,hgYs,hgZs);
521
522    // Position der Schneide am Messerkopf
523    // (jetzt die Ber"ucksichtigung von hgKopSpW, hgFlaSpW, hgMeSchW)
524    D2T(f,hgMeSchW);     // Messerschwenkwinkel Theta_M
525    D3T(f,hgFlaSpW);     // Flankenspanwinkel Theta_F
526    D1(f,hgKopSpW);      // Kopfspanwinkel Theta_K
527    // Position der Schneide am Messerkopf
528    f[0] += hgFlKrRd;    // Flugkreisradius
529    f[1] -= hgXmk;       // Messerversatz
530
531    // Messerkopfrotation mit Parameter v
532    D3(f,z[1]);
533
534    // Lage des Messerkopfs auf der Wiege
535    f[2] -= hgYmk;
536
537    // Beruecksichtigung der Messerkopf-Exzentrizitaet
538    f[0] += hgE * cos(hgExzenW);
539    f[1] -= hgE * sin(hgExzenW);
540
541    // Eindrehen in Orientierung der Wiege
542    ah = f[0];
543    f[0] = f[1];
544    f[1] = ah;
545    f[2] = -f[2];
546
547    // Beruecksichtigung von Messerkopf-Schwenkwinkel hgThetaS
548    // und der Messerkopfneigung hgThetaN
549    D3T(f,hgThetaS);     // Einschwenken in die Neigungsachse
550    D1T(f,hgThetaN);     // Neigung um x-Achse
551    D3(f,hgThetaS);      // Rueckschwenken aus der Neigungsachse
552
553    // Verschiebung
554    f[0] -= hgXmw;       // FLB1-x-Achse zeigt nach oben     -> (-xNeu)
555    f[1] += hgZmw;       // FLB1-z-Achse zeigt nach rechts   ->  (yNeu)
556    f[2] += hgYmw;       // FLB1-y-Achse zeigt aus der Wiege ->  (zNeu)
557
558    // Wiegenwinkel thetaW, entspricht dem wert t=0
559    D3(f,hgThetaW);
560
561    // ZUSATZBEWEGUNG Radial motion
562    if (radialMotionDegree >= 0) {
563        ah = 0.0;
564        for (i=radialMotionDegree; i>0; i--) {
565            ah += radialMotionCoeff[i];
566            ah *= z[2];
567        }
568        ah += radialMotionCoeff[0];
569        f[1] += ah;        // radiale Verschiebung des Messerkopfes
570    }
571
572    // Wiegenbewegung mit Parameter t
573    D3(f,z[2]);
574
575    // ZUSATZBEWEGUNG Vertical motion
576    if (verticalMotionDegree >= 0) {
577        ah = 0.0;
578        for (i=verticalMotionDegree; i>0; i--) {
579            ah += verticalMotionCoeff[i];
580            ah *= z[2];
581        }
582        ah += verticalMotionCoeff[0];
583        f[0] += ah;        // Achsversatz in positive x-Richtung
584    }
585
586    // originaler Achsversatz
587    f[0] += hgM;
588
589    // ZUSATZBEWEGUNG Horizontal motion
590    if (horizontalMotionDegree >= 0) {
591        ah = 0.0;
592        for (i=horizontalMotionDegree; i>0; i--) {
593            ah += horizontalMotionCoeff[i];
594            ah *= z[2];
595        }
596        ah += horizontalMotionCoeff[0];
597        f[1] += ah;        // Achsversatz in positive y-Richtung
598    }
599
600    // ZUSATZBEWEGUNG Helical motion
601    if (helicalMotionDegree >= 0) {
602        ah = 0.0;
603        for (i=helicalMotionDegree; i>0; i--) {
604            ah += helicalMotionCoeff[i];
605            ah *= z[2];
606        }
607        ah += helicalMotionCoeff[0];
608        f[2] -= ah;        // Tiefenposition in negative z-Richtung
609    }
610
611    // Eindrehen in Orientierung des Werkrades
612    f[0] = -f[0];
613    ah = f[1];
614    f[1] = -f[2];
615    f[2] = -ah;
616
617    // ZUSATZBEWEGUNG Angular motion
618    if (angularMotionDegree >= 0) {
619        ah = 0.0;
620        for (i=angularMotionDegree; i>0; i--) {
621            ah += angularMotionCoeff[i];
622            ah *= z[2];
623        }
624        ah += angularMotionCoeff[0];
625        D1(f,ah);        // umgekehrte Drehung um die x-Achse
626    }
627
628    // Teilkegeloeffnungswinkel delta - y-Achsen entgegengesetzt
629    D1(f,hgDelta);
630
631    // neue Verschiebung der Werkradachse
632    f[2] += hgZwr; // z-Achse zeigt zu Spitze
633
634    // ZUSATZBEWEGUNG Modified roll
635    if (modifiedRollDegree >= 0) {
636        ah = 0.0;
637        for (i=modifiedRollDegree; i>1; i--) {
638            ah += modifiedRollCoeff[i];
639            ah *= z[2];
640        }
641        if (modifiedRollDegree > 0)
642            ah += modifiedRollCoeff[1];
643        ah += hgOmega;
644        ah *= z[2];
645        ah += modifiedRollCoeff[0];
646    } else {
647        ah = hgOmega;
648        ah *= z[2];
649    }
650    ah += hgC*z[1];   // c*v + omega * t
651    // gekoppelte Werkraddrehung in Abhaengigkeit von t und v
652    D3(f,ah);
653}
654
655
656/*--------------------------------------------------------------------------*/
657/*                                                   The interface function */
658void tapingVectorFunction( int tag, double* indeps, double* deps ) {
659    int i;
660    trace_on(tag);
661    adouble* activeIndeps = new adouble[indepDim];
662    adouble* activeDeps   = new adouble[depDim];
663    adouble* aIP = activeIndeps;
664    double*  iP  = indeps;
665    for (i=0; i<indepDim; i++)
666        *aIP++ <<= *iP++;
667
668    i = 3;
669    adouble * activeRadMotCoeff = activeIndeps+i;
670    i += radMotDegree;
671    adouble * activeVerMotCoeff = activeIndeps+i;
672    i += verMotDegree;
673    adouble * activeHorMotCoeff = activeIndeps+i;
674    i += horMotDegree;
675    adouble * activeHelMotCoeff = activeIndeps+i;
676    i += helMotDegree;
677    adouble * activeAngMotCoeff = activeIndeps+i;
678    i += angMotDegree;
679    adouble * activeModRolCoeff = activeIndeps+i;
680
681    activeGearFunction(
682        activeIndeps,
683        activeDeps,
684        // jetzt kommen die ganzen Parameter
685        xmk,    // Messerversatz
686        ymk,    // MK-Versatz
687        kopspw, // Kopfspanwinkel
688        flaspw, // Flankenspanwinkel
689        meschw, // Messerschwenkwinkel
690        flkrrd, // Flugkreisradius
691        e,      // Exzentrizitaet
692        exzenw, // Exzentrizitaetswinkel
693        thetas, // Messerkopfschwenkung
694        thetan, // Messerkopfneigung
695        xmw,    // MK-x
696        ymw,    // MK-y
697        zmw,    // MK-z
698        thetaw, // Wiegenwinkel
699        m,      // Achsversatz
700        zwr,    // Verschiebung Werkradachse
701        delta,  // Teilkegeloeffnungswinkel
702        omega,  //
703        c,
704        r,      // Kopfradius
705        rs,     // Sphaerikradius
706        ys,     // Sphaerik-Mitte-Y
707        zs,     // Sphaerik-Mitte-Z
708        // jetzt die Zusatzbewegungen
709        radMotDegree,
710        activeRadMotCoeff,
711        verMotDegree,
712        activeVerMotCoeff,
713        horMotDegree,
714        activeHorMotCoeff,
715        helMotDegree,
716        activeHelMotCoeff,
717        angMotDegree,
718        activeAngMotCoeff,
719        modRolDegree,
720        activeModRolCoeff
721    );
722
723    aIP = activeDeps;
724    iP  = deps;
725    for (i=0; i<depDim; i++)
726        *aIP++ >>= *iP++;
727    trace_off();
728
729    delete [] activeDeps;
730    delete [] activeIndeps;
731}
732
733#undef _VFUNC_GEAR_C_
734
735
736
737
738
Note: See TracBrowser for help on using the repository browser.