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

Last change on this file since 40 was 40, checked in by awalther, 10 years ago

adapted directoy structure

File size: 22.4 KB
Line 
1/*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File:     vfunc_pargear.cpp
4 Revision: $Id: vfunc_pargear.cpp 300 2009-02-26 10:42:44Z awalther $
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.h>
32#include <../examples/additional_examples/timing/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.