sciencetalk

 Hallo

Ik zou graag een script/programma willen schrijven dat een dip in een dataset kan detecteren.

Nu ik heb wel een idee hoe ik dit zou kunnen doen (met de afgeleide) maar hoe ik dit praktisch kan aanpakken is mij nog niet helemaal duidelijk.

Ik kan wel wat programmeren in VB of C# maar  ben er toch nog niet helemaal uit.

Kunnen jullie mij op weg zetten om soortgelijke data-analyse te automatiseren.

Data die ik zou willen analyseren ziet er als volgt uit (in de praktijk natuurlijk met wat ruis).
 
 

Allereerst moet je van de ruis af. Als je de ruis zou differentiëren krijg afhankelijk van de frequenties die daarin voorkomen, direct een vals signaal. Dat kun je doen met een laagdoorlaatfilter. Een tweepolig filter doet het meestal wel goed. Bij voorkeur heeft dat filter geen doorschot; dat zou de originele datastroom kunnen aantasten. Dat programmeer je als volgt:
 
Noem de te analyseren datastroom Vi[n]. De gefilterde datastroom wordt afgeleverd in Vo[n]. ‘n’ geeft het volgnummer van de te analyseren data weer. 
Dan zijn er twee tussen variabelen nodig Y[n-1] en Y[n-2]. 
Alle velden worden geïnitialiseerd met de waarde ‘0’.
Er zijn twee constanten: P en Q. 
Q bepaalt de mate van ruisonderdrukking. Bij een waarde van 3,2 geeft het filter geen doorschot. Bij een lagere waarde is de ruisonderdrukking beter maar ontstaat er wel doorschot. Bij Q=2 is er ongeveer 5% doorschot.
P bepaalt de kantelfrequentie van het filter. Je wilt de ruis eruit hebben maar niet de verschijnselen die je wilt detecteren.
In een loop worden de volgende instructies geprogrammeerd:
 
Y[n-1] = P.Q.Vi[n-2] + (P.(1-Q)+1).Y[n-2] - P.Vo[n-2] 
Vo[n] = P.Y[n-1] + (1-P).Vo[n-1]
 
Zo verkrijg je een gefilterde dataset. Als de data real time verwerkt wordt dient de loop ook met een vaste herhalingstijd te worden uitgevoerd. De frequentie van de loop is recht evenredig met de kantelfrequentie van het filter.
Het differentiëren van het verkregen signaal om een dip te detecteren is niet zo moeilijk. De eerste afgeleide vind je door:
 
Vo[n]’ = Vo[n] – Vo[n-1]
 
Ik hoop dat je zo voldoende hebt om te beginnen.

Heel erg bedankt voor je antwoord, hier kan ik mee verder!
Mijn excuses voor het late antwoord.

Olof Bosma schreef: Dan zijn er twee tussen variabelen nodig Y[n-1] en Y[n-2]. 
Alle velden worden geïnitialiseerd met de waarde ‘0’.

Ik ben niet helemaal wat deze tussen variabelen zijn.

Ik heb het proberen uit te werken maar loop wel vast.

Misschien kan jij me verder helpen ?

n | VI |VO |Y 
0 | 3  | ? |?
1 | 5  | ? |?
2 | 9  | ? |?
 
n =0
Vo[0] = 0   
 
n=1             
Vo[1] = P.Y[1-1] + (1-P).Vo[1-1]
Y[1-1]  --> Y[n-1] = P.Q.Vi[1-2] + (P.(1-Q)+1).Y[1-2] - P.Vo[1-2] 
Vo[1-2] -> ?
Vi[1-2] -> ?
Y[1-2] -> ?
 
n=2   
Vo[2] = P.Y[2-1] + (1-P).Vo[2-1]
Y[2-1] = P.Q.Vi[2-2] + (P.(1-Q)+1).Y[2-2] - P.Vo[2-2] 
Vi[2-2]= 3
Y[2-2] =Y0 ?
Vo[2-2] = 0
 
n=3
Vo[3] = P.Y[3-1] + (1-P).Vo[3-1]
Y[3-1] = P.Q.Vi[3-2] + (P.(1-Q)+1).Y[3-2] - P.Vo[3-2]
Vi[3-2] = 5
Y[3-2] = Y1 ?
Vo[3-2] = ?

 

Misschien heb je wat aan een paar voorbeelden op basis van jouw getallen:
 
als P = 0,5    Q = 3,2
 
n    VI    VO      Y
0     0     0         0
1     3     0         0
2     5     0       4,8
3     9    2,4     7,52
 
Bij P = 0,5 ligt de kantelfrequentie onrealistisch hoog; zelfs deze snelle storingspuls zie je nu door het filter komen. Iets meer realistisch is P = 0,05:
 
als P = 0,05    Q = 3,2
 
n    VI    VO      Y
0     0     0         0
1     3     0         0
2     5     0       0,48
3     9   0,024 1,227
 
Nu wordt deze storingspuls al veer beter onderdrukt. Realistisch is P = 0,005:
 
als P = 0,005    Q = 3,2
 
n    VI    VO      Y
0     0      0        0
1     3      0        0
2     5      0       0,048
3     9 0,00024 0,1275
 
Nu zie je dat deze snelle storingspuls flink wordt onderdrukt.

Een beter inzicht in het algoritme krijg je als je de testpuls wat uitbreidt en laat volgen door een negatieve puls.
Wat je dan ziet is dat na de puls een kleine waarde overblijft (ongeveer 10%) doordat de puls gemiddeld positief was. Als de dan de negatieve puls volgt neutraliseert dat weer naar ongeveer nul. Om dit binnen een overzichtelijk aantal samples zichtbaar te krijgen heb ik de kantelfrequentie P = 0,05 gezet.
Q = 3,2.
In werkelijkheid kun je de kantelfrequentie beter rond 0,005 leggen en als het hoger moet de cyclustijd verkorten.
 
De tabel blijkt niet direct zichtbaar te krijgen dus daarom maar in Excel-formaat bijgevoegd.
 

Ik heb even zelf wat data toegevoegd.

Het is mij wel (nog) niet gelukt om de dip te detecteren in de afgeleide.
 
(is de bijlage gelukt ?)

Hier is de bijlage

In jouw voorbeeld staat de kantelfrequentie veel te laag ingesteld; hierdoor wordt ook de puls die je wilt detecteren 'plat' gefilterd. Als ik in jouw spread sheet P = 0,5 instel, wordt de puls netjes gedetecteerd. Je programma werkt dus prima.
Het is in zulke gevallen altijd nauwkeurig mikken met de kantelfrequentie; de ruis moet zoveel mogelijk weg maar de te meten signalen moeten wel blijven zitten.
Overigens begin je het inkomend signaal aan de start plotseling met een waarde van 40,8242. Dat is in dit voorbeeld nu de grootste sprong die er dan ook in het uitgangssignaal uit knalt.
Ik adviseer je wel als dat mogelijk is P lager te houden en de sample rate te verhogen. De berekening geeft dan meer resolutie.

Bedankt voor alle hulp Olof Bosma !