kill(all);

da pagg. 8,9 Barber , ivi derivate dai circoli di Mohr

definisco le quantità ausiliarie

c : cos(t)$
s : sin(t)$

define(
    srr_from_xy(sxx,syy,sxy,t),
    sxx*c^2 + syy*s^2+2*sxy*s*c
);

define(
    srt_from_xy(sxx,syy,sxy,t),
    sxy*(c^2-s^2)+(syy-sxx)*s*c
);

define(
    stt_from_xy(sxx,syy,sxy,t),
    syy*c^2 + sxx*s^2-2*sxy*s*c
);

non servono più le quantità ausiliarie

kill(c,s)$

mostro le condizioni al contorno di far field, nel caso specifico

sxx_ff: 1$
syy_ff:-1$
sxy_ff: 0$

porto in rappresentazione di serie di Fourier , finita

[srr_ff,stt_ff,srt_ff]
:
trigreduce(
    [ 
        srr_from_xy(sxx_ff,syy_ff,sxy_ff,t) , 
        stt_from_xy(sxx_ff,syy_ff,sxy_ff,t) , 
        srt_from_xy(sxx_ff,syy_ff,sxy_ff,t) 
    ]);

inserisco i termini della soluzione secondo Michell che ritengo appropriati
al caso specifico

philist : [ 
    r^2 , 
    log(r) ,
    t, 
    r^(-n+2)*cos(n*t), 
    r^n*cos(n*t) , 
    r^(-n)*cos(n*t)
],n=2;

creo le liste di componenti di tensione

srrlist : 1/r * diff( philist , r , 1) + 1/r^2*diff( philist , t , 2 );
sttlist : diff( philist , r , 2 );
srtlist : 1/r^2 * diff(philist, t,1) - 1/r * diff(philist,r,1,t,1);

inseristo le funzioni di spostamento associate a tali termini della soluzione di Michell

tmurlist : [ 
    (kappa-1)*r , 
    -1/r ,
    0, 
    (kappa+n-1)*r^(-n+1)*cos(n*t), 
            -n *r^( n-1)*cos(n*t) , 
             n *r^(-n-1)*cos(n*t)
],n=2;

tmutlist : [ 
    0 , 
    0 ,
    -1/r, 
   -(kappa-n+1)*r^(-n+1)*sin(n*t), 
             n *r^( n-1)*sin(n*t) , 
             n *r^(-n-1)*sin(n*t)
],n=2;

combino i termini di phi

numero di termini

m:length(philist);

associate incognite

unks : makelist(A[i],i,1,m);

specifica funzione phi, e specifiche forme di spostamento

myphi : sum(  unks[i]*philist[i],i,1,m);

mysrr : sum(  unks[i]*srrlist[i],i,1,m);

mystt : sum(  unks[i]*sttlist[i],i,1,m);

mysrt : sum(  unks[i]*srtlist[i],i,1,m);

mytmur : sum(  unks[i]*tmurlist[i],i,1,m);

mytmut : sum(  unks[i]*tmutlist[i],i,1,m);

condizioni al contorno:

quotaparte a remoto

farfield_bc_eq: 
    [
        limit(mysrr,r,infinity)-srr_ff,
        limit(mystt,r,infinity)-stt_ff,
        limit(mysrt,r,infinity)-srt_ff
    ];

quotaparte locale al foro

foro_bc_eq:
    [
        ev(mysrr,r=1)-0,
        ev(mysrt,r=1)-0
    ];

lista cumulativa equazioni

eq:append(farfield_bc_eq,foro_bc_eq);

questi residui sono da annullarsi PER OGNI t.
Come procedo?
ne estraggo un rappresentazione in serie di Fourier

eq_A0 : (1/2/%pi)*integrate(eq,t,0,2*%pi);

eq_A2 : fullratsimp ( (1/%pi)*integrate(eq*cos(2*t),t,0,2*%pi) );

eq_B2 : fullratsimp ( (1/%pi)*integrate(eq*sin(2*t),t,0,2*%pi) );

linsolve( append(eq_A0,eq_A2,eq_B2) ,unks),globalsolve=true;

controllo che il residuo sia effettivamente annullato

fullratsimp(  ev(eq)  );

ok!

plotme:[
    ev(mystt,r=1),
    srr_ff,
    stt_ff,
    srt_ff
];
plotme_legend:[ legend,
    "stt, bordo foro",
    "srr, ff",
    "stt, ff",
    "srt, ff"
]$
wxplot2d(plotme,[t,0,2*%pi],plotme_legend);