void processAudio(AudioBuffer& buf){
float minf = getParameterValue(PARAMETER_A)*0.1 + 0.001;
float maxf = min(0.4, minf + getParameterValue(PARAMETER_B)*0.2);
// range should be exponentially related to minf
// int tones = getParameterValue(PARAMETER_C)*(TONES-1) + 1;
int tones = 12;
float spread = getParameterValue(PARAMETER_C) + 1.0;
float rate = 1.0 + (getParameterValue(PARAMETER_D) - 0.5)*0.00002;
int size = buf.getSize();
FloatArray out = buf.getSamples(LEFT_CHANNEL);
float amp;
for(int t=1; t<tones; ++t)
inc[t] = inc[t-1]*spread;
for(int i=0; i<size; ++i){
for(int t=0; t<tones; ++t){
amp = getAmplitude((inc[t]-minf)/(maxf-minf));
out[i] += amp * getWave(acc[t]);
acc[t] += inc[t];
if(acc[t] > 1.0)
acc[t] -= 1.0;
else if(acc[t] < 0.0)
acc[t] += 1.0;
inc[t] *= rate;
}
}
if(inc[0] > maxf)
inc[0] = minf;
// while(inc[0] > minf)
// inc[0] *= 0.5;
else if(inc[0] < minf)
inc[0] = maxf;
// while(inc[0] < maxf)
// inc[0] *= 2.0;
}
void levelQueueReader() {
Keyword current;
KeywordQueue kQueue = getKWQueue(NULL);
current = kQueue->start;
while(current != NULL) {
switch(current->lCommand) {
case wave:
//! only expands waves into create enemies commands if it is at the start of the queue
if(kQueue->start == current && getWave(getGame(NULL)) == returnPropertyValue(current,waveID)) {
increaseEnemyNumbersThisWave(returnPropertyValue(current,numberOfEnemies));
waveCreatorCommand(current);
current = removeLink(current);
} else {
current = current->prev;
}
break;
case makeEnemy:
if(createEnemyCommand(current)) {
current = removeLink(current);
return;
} else {
return;
}
break;
case delay:
setCreateEnemyGroupDelay(returnPropertyValue(current,dTime));
current = removeLink(current);
return;
break;
default:
break;
}
}
}
void CreateGameTest() {
GameProperties testGame;
testGame = createGame();
sput_fail_if((createGame()) == NULL,"Creating Game");
sput_fail_unless(getAvailableMemory(testGame) == 0,"Initializing Memory");
sput_fail_unless(getWave(testGame) == 0,"Initializing WaveNo");
sput_fail_unless(getHealth(testGame) == 0,"Initializing Health");
free(testGame);
}
int startNextWave() {
if(getTotalCurrentWaveEnemies() == getDeathCnt()) {
if(getWave(getGame(NULL)) < getTotalWaveNo()) {
resetEnemyCounts();
setCurrWaveNum(getGame(NULL)->currWaveNo+1);
} else {
//printf("you have won the level\n");
}
return 1;
}
return 0;
}
void WaveEventBase::read(Xml& xml)
{
for (;;)
{
Xml::Token token = xml.parse();
const QString& tag = xml.s1();
switch (token)
{
case Xml::Error:
case Xml::End:
case Xml::Attribut:
return;
case Xml::TagStart:
if (tag == "poslen")
PosLen::read(xml, "poslen");
else if (tag == "frame")
_spos = xml.parseInt();
else if(tag == "leftclip")
m_leftclip = xml.parseInt();
else if(tag == "rightclip")
m_rightclip = xml.parseInt();
else if (tag == "file")
{
SndFile* wf = getWave(xml.parse1(), true);
if (wf)
{
f = SndFileR(wf);
}
}
else
xml.unknown("Event");
break;
case Xml::TagEnd:
if (tag == "event")
{
Pos::setType(FRAMES); // DEBUG
return;
}
default:
break;
}
}
}
PathHandle Direction::getPathHandle() {
return getWave();
}
int createEnemyCommand(Keyword makeEnemy) {
//! only create enemy if all cooldowns are ready
if(checkClock(singleEnemyCreated,ENEMYSPAWNCOOLDOWN) && checkClock(groupDelay,getEnemyGroupDelay()) && (getWave(getGame(NULL)) == returnPropertyValue(makeEnemy,waveID))) {
setCreateEnemyGroupDelay(0); //!setting delay back to zero
createSpecificEnemy(returnPropertyValue(makeEnemy,enemyType),returnPropertyValue(makeEnemy,enemyLevel),returnPropertyValue(makeEnemy,entrance));
return 1;
}
return 0;
}
TGraph *getWave(int diskNum, int fileNum)
{
char filename[180];
sprintf(filename,"/home/rjn/saltStuff/salt_trip3_data/disk_%d/TEK%05d.CSV",diskNum,fileNum);
return getWave(filename);
}
void plotAbbyTimeThings()
{
gSystem->Load("libMathMore.so");
gSystem->Load("/sw/lib/libfftw3.so");
gSystem->Load("libRootFftwWrapper.so");
readAbbyTimeFile();
char canName[180];
char graphTitle[180];
TF1 *fpl = new TF1("fpl",funcPowerLaw,10,1000,2);
fpl->SetParameters(3.281e6,-0.5484);
TGraph *grAtten[1000];
int antIndex=2;
char outName[180];
sprintf(outName,"%sErrorTimeSlide.txt",antName[antIndex]);
ofstream AbbyNumbers(outName);
sprintf(outName,"%sErrorTimeSlideArrays.C",antName[antIndex]);
ofstream AbbyArrays(outName);
TCanvas *canAtten = new TCanvas("canAtten","canAtten",1000,800);
TCanvas *canPower12 = new TCanvas("canPower12","canPower12",1000,800);
TCanvas *canPower13 = new TCanvas("canPower13","canPower13",1000,800);
canAtten->Divide(canDivide[antIndex][0],canDivide[antIndex][1]);
canPower12->cd();
gPad->SetLogy();
TH1F *frame12 = canPower12->DrawFrame(10,1e4,1200,1e11);
canPower13->cd();
gPad->SetLogy();
TH1F *frame13 = canPower13->DrawFrame(10,100,1200,1e8);
for(int i=0;i<numDepths[antIndex];i++) {
canAtten->cd(i+1);
sprintf(canName,"Depth %d",depths[antIndex][i]);
gPad->SetLogy(1);
gPad->SetLogx(1);
TH1F *framey = gPad->DrawFrame(30,10,1000,1000,canName);
Double_t meanPower12[100]={0};
Double_t meanSqPower12[100]={0};
Double_t meanPower13[100]={0};
Double_t meanSqPower13[100]={0};
Double_t freqVal[100]={0};
Int_t numPowPoints=0;
TGraph *grT12=getWave(disks[antIndex][i][0],files[antIndex][i][0]);
TGraph *grT13=getWave(disks[antIndex][i][1],files[antIndex][i][1]);
int count=0;
for(Double_t dt=-3e-9;dt<3e-9;dt+=0.25e-9) {
TGraph *grT12Crop = cropWave(grT12,(1e-9*peakTime[antIndex][i][0]+antDtLeft[antIndex])+dt,1e-9*peakTime[antIndex][i][0]+antDtRight[antIndex]+dt);
TGraph *grT13Crop = cropWave(grT13,(1e-9*peakTime[antIndex][i][1]+antDtLeft[antIndex])+dt,1e-9*peakTime[antIndex][i][1]+antDtRight[antIndex]+dt);
// TGraph *grT12Crop = cropWave(grT12,1e-9*minTime[antIndex][i][0]+dt,1e-9*maxTime[antIndex][i][0]+dt);
// TGraph *grT13Crop = cropWave(grT13,1e-9*minTime[antIndex][i][1]+dt,1e-9*maxTime[antIndex][i][1]+dt);
TGraph *grPower12 = FFTtools::makePowerSpectrumVoltsSeconds(grT12Crop);
TGraph *grPower13 = FFTtools::makePowerSpectrumVoltsSeconds(grT13Crop);
TGraph *grPower12dB = convertToDb(grPower12);
TGraph *grPower13dB = convertToDb(grPower13);
sprintf(graphTitle,"Hole 1 - Hole 2 -- Depth %d (Christian)",depths[antIndex][i]);
grT12->SetTitle(graphTitle);
grPower12->SetTitle(graphTitle);
grPower12dB->SetTitle(graphTitle);
sprintf(graphTitle,"Hole 1 - Hole 3 -- Depth %d (Christian)",depths[antIndex][i]);
grT13->SetTitle(graphTitle);
grPower13->SetTitle(graphTitle);
grPower13dB->SetTitle(graphTitle);
Double_t power12=FFTtools::integrateVoltageSquared(grT12Crop);
Double_t power13=FFTtools::integrateVoltageSquared(grT13Crop);
TGraphErrors *grPowInt12 = integratePowerSpectrum(grPower12,antFreqCentres[antIndex],antFreqWidth[antIndex],antFreqNumBins[antIndex]);
TGraphErrors *grPowInt13 = integratePowerSpectrum(grPower13,antFreqCentres[antIndex],antFreqWidth[antIndex],antFreqNumBins[antIndex]);
sprintf(graphTitle,"grAtten%d_%d",depths[antIndex][i],count);
grAtten[count]=getAttenLengthGraph(grPowInt12,grPowInt13);
grAtten[count]->SetName(graphTitle);
// grAtten[count]->SetLineColor(getNiceColour(count));
// grAtten[count]->SetMarkerColor(getNiceColour(count));
grAtten[count]->SetLineColor(count);
grAtten[count]->SetMarkerColor(count);
grAtten[count]->Draw("lp");
fpl->Draw("same");
numPowPoints=grPowInt13->GetN();
Double_t *pow12Vals=grPowInt12->GetY();
Double_t *pow13Vals=grPowInt13->GetY();
Double_t *freq13Vals=grPowInt13->GetX();
for(int powi=0;powi<numPowPoints;powi++) {
meanPower12[powi]+=pow12Vals[powi];
meanSqPower12[powi]+=pow12Vals[powi]*pow12Vals[powi];
meanPower13[powi]+=pow13Vals[powi];
meanSqPower13[powi]+=pow13Vals[powi]*pow13Vals[powi];
freqVal[powi]=freq13Vals[powi];
}
count++;
}
//Now just slide the 12 window
for(Double_t dt=-3e-9;dt<3e-9;dt+=0.25e-9) {
TGraph *grT12Crop = cropWave(grT12,(1e-9*peakTime[antIndex][i][0]+antDtLeft[antIndex])+dt,1e-9*peakTime[antIndex][i][0]+antDtRight[antIndex]+dt);
TGraph *grT13Crop = cropWave(grT13,(1e-9*peakTime[antIndex][i][1]+antDtLeft[antIndex]),1e-9*peakTime[antIndex][i][1]+antDtRight[antIndex]);
// TGraph *grT12Crop = cropWave(grT12,1e-9*minTime[antIndex][i][0]+dt,1e-9*maxTime[antIndex][i][0]+dt);
// TGraph *grT13Crop = cropWave(grT13,1e-9*minTime[antIndex][i][1]+dt,1e-9*maxTime[antIndex][i][1]+dt);
TGraph *grPower12 = FFTtools::makePowerSpectrumVoltsSeconds(grT12Crop);
TGraph *grPower13 = FFTtools::makePowerSpectrumVoltsSeconds(grT13Crop);
TGraph *grPower12dB = convertToDb(grPower12);
TGraph *grPower13dB = convertToDb(grPower13);
sprintf(graphTitle,"Hole 1 - Hole 2 -- Depth %d (Christian)",depths[antIndex][i]);
grT12->SetTitle(graphTitle);
grPower12->SetTitle(graphTitle);
grPower12dB->SetTitle(graphTitle);
sprintf(graphTitle,"Hole 1 - Hole 3 -- Depth %d (Christian)",depths[antIndex][i]);
grT13->SetTitle(graphTitle);
grPower13->SetTitle(graphTitle);
grPower13dB->SetTitle(graphTitle);
Double_t power12=FFTtools::integrateVoltageSquared(grT12Crop);
Double_t power13=FFTtools::integrateVoltageSquared(grT13Crop);
TGraphErrors *grPowInt12 = integratePowerSpectrum(grPower12,antFreqCentres[antIndex],antFreqWidth[antIndex],antFreqNumBins[antIndex]);
TGraphErrors *grPowInt13 = integratePowerSpectrum(grPower13,antFreqCentres[antIndex],antFreqWidth[antIndex],antFreqNumBins[antIndex]);
sprintf(graphTitle,"grAtten%d_%d",depths[antIndex][i],count);
grAtten[count]=getAttenLengthGraph(grPowInt12,grPowInt13);
grAtten[count]->SetName(graphTitle);
// grAtten[count]->SetLineColor(getNiceColour(count));
// grAtten[count]->SetMarkerColor(getNiceColour(count));
grAtten[count]->SetLineColor(count);
grAtten[count]->SetMarkerColor(count);
grAtten[count]->Draw("lp");
fpl->Draw("same");
numPowPoints=grPowInt13->GetN();
Double_t *pow12Vals=grPowInt12->GetY();
Double_t *pow13Vals=grPowInt13->GetY();
Double_t *freq13Vals=grPowInt13->GetX();
for(int powi=0;powi<numPowPoints;powi++) {
meanPower12[powi]+=pow12Vals[powi];
meanSqPower12[powi]+=pow12Vals[powi]*pow12Vals[powi];
meanPower13[powi]+=pow13Vals[powi];
meanSqPower13[powi]+=pow13Vals[powi]*pow13Vals[powi];
freqVal[powi]=freq13Vals[powi];
}
count++;
}
cout << count << endl;
//Now just slide the 13 window
for(Double_t dt=-3e-9;dt<3e-9;dt+=0.25e-9) {
TGraph *grT12Crop = cropWave(grT12,(1e-9*peakTime[antIndex][i][0]+antDtLeft[antIndex]),1e-9*peakTime[antIndex][i][0]+antDtRight[antIndex]);
TGraph *grT13Crop = cropWave(grT13,(1e-9*peakTime[antIndex][i][1]+antDtLeft[antIndex])+dt,1e-9*peakTime[antIndex][i][1]+antDtRight[antIndex]+dt);
// TGraph *grT12Crop = cropWave(grT12,1e-9*minTime[antIndex][i][0]+dt,1e-9*maxTime[antIndex][i][0]+dt);
// TGraph *grT13Crop = cropWave(grT13,1e-9*minTime[antIndex][i][1]+dt,1e-9*maxTime[antIndex][i][1]+dt);
TGraph *grPower12 = FFTtools::makePowerSpectrumVoltsSeconds(grT12Crop);
TGraph *grPower13 = FFTtools::makePowerSpectrumVoltsSeconds(grT13Crop);
TGraph *grPower12dB = convertToDb(grPower12);
TGraph *grPower13dB = convertToDb(grPower13);
sprintf(graphTitle,"Hole 1 - Hole 2 -- Depth %d (Christian)",depths[antIndex][i]);
grT12->SetTitle(graphTitle);
grPower12->SetTitle(graphTitle);
grPower12dB->SetTitle(graphTitle);
sprintf(graphTitle,"Hole 1 - Hole 3 -- Depth %d (Christian)",depths[antIndex][i]);
grT13->SetTitle(graphTitle);
grPower13->SetTitle(graphTitle);
grPower13dB->SetTitle(graphTitle);
Double_t power12=FFTtools::integrateVoltageSquared(grT12Crop);
Double_t power13=FFTtools::integrateVoltageSquared(grT13Crop);
TGraphErrors *grPowInt12 = integratePowerSpectrum(grPower12,antFreqCentres[antIndex],antFreqWidth[antIndex],antFreqNumBins[antIndex]);
TGraphErrors *grPowInt13 = integratePowerSpectrum(grPower13,antFreqCentres[antIndex],antFreqWidth[antIndex],antFreqNumBins[antIndex]);
sprintf(graphTitle,"grAtten%d_%d",depths[antIndex][i],count);
grAtten[count]=getAttenLengthGraph(grPowInt12,grPowInt13);
grAtten[count]->SetName(graphTitle);
// grAtten[count]->SetLineColor(getNiceColour(count));
// grAtten[count]->SetMarkerColor(getNiceColour(count));
grAtten[count]->SetLineColor(count);
grAtten[count]->SetMarkerColor(count);
grAtten[count]->Draw("lp");
fpl->Draw("same");
numPowPoints=grPowInt13->GetN();
Double_t *pow12Vals=grPowInt12->GetY();
Double_t *pow13Vals=grPowInt13->GetY();
Double_t *freq13Vals=grPowInt13->GetX();
for(int powi=0;powi<numPowPoints;powi++) {
meanPower12[powi]+=pow12Vals[powi];
meanSqPower12[powi]+=pow12Vals[powi]*pow12Vals[powi];
meanPower13[powi]+=pow13Vals[powi];
meanSqPower13[powi]+=pow13Vals[powi]*pow13Vals[powi];
freqVal[powi]=freq13Vals[powi];
}
count++;
}
Double_t rms12Val[100];
Double_t rms13Val[100];
Double_t err12Val[100];
Double_t err13Val[100];
for(int powi=0;powi<numPowPoints;powi++) {
meanPower12[powi]/=count;
meanSqPower12[powi]/=count;
meanPower13[powi]/=count;
meanSqPower13[powi]/=count;
rms12Val[powi]=TMath::Sqrt(meanSqPower12[powi]-meanPower12[powi]*meanPower12[powi]);
rms13Val[powi]=TMath::Sqrt(meanSqPower13[powi]-meanPower13[powi]*meanPower13[powi]);
err12Val[powi]=rms12Val[powi]/TMath::Sqrt(count);
err13Val[powi]=rms13Val[powi]/TMath::Sqrt(count);
}
AbbyNumbers << antIndex << "\t" << depths[antIndex][i] << "\t" << 2 << "\t";
AbbyArrays << "meanPowerArray_" << antIndex << "_" << depths[antIndex][i] << "_" << 2 << "[" << numPowPoints << "]={";
for(int powi=0;powi<numPowPoints;powi++) {
AbbyNumbers << meanPower12[powi] << "\t" << rms12Val[i] << "\t";
AbbyArrays << meanPower12[powi];
if(powi<numPowPoints-1)
AbbyArrays << ",";
else
AbbyArrays << "};\n";
}
AbbyArrays << "rmsPowerArray_" << antIndex << "_" << depths[antIndex][i] << "_" << 2 << "[" << numPowPoints << "]={";
for(int powi=0;powi<numPowPoints;powi++) {
AbbyArrays << rms12Val[powi];
if(powi<numPowPoints-1)
AbbyArrays << ",";
else
AbbyArrays << "};\n";
}
AbbyArrays << "meanPowerArray_" << antIndex << "_" << depths[antIndex][i] << "_" << 3 << "[" << numPowPoints << "]={";
for(int powi=0;powi<numPowPoints;powi++) {
AbbyArrays << meanPower13[powi];
if(powi<numPowPoints-1)
AbbyArrays << ",";
else
AbbyArrays << "};\n";
}
AbbyArrays << "rmsPowerArray_" << antIndex << "_" << depths[antIndex][i] << "_" << 3 << "[" << numPowPoints << "]={";
for(int powi=0;powi<numPowPoints;powi++) {
AbbyArrays << rms13Val[powi];
if(powi<numPowPoints-1)
AbbyArrays << ",";
else
AbbyArrays << "};\n";
}
AbbyNumbers << "\n";
AbbyNumbers << antIndex << "\t" << depths[antIndex][i] << "\t" << 3 << "\t";
for(int powi=0;powi<numPowPoints;powi++) {
AbbyNumbers << meanPower13[powi] << "\t" << rms13Val[i] << "\t";
}
AbbyNumbers << "\n";
TGraphErrors *grPowErr12 = new TGraphErrors(numPowPoints,freqVal,meanPower12,0,rms12Val);
TGraphErrors *grPowErr13 = new TGraphErrors(numPowPoints,freqVal,meanPower13,0,rms13Val);
canPower12->cd();
grPowErr12->SetLineColor(getNiceColour(i));
grPowErr12->SetMarkerColor(getNiceColour(i));
grPowErr12->Draw("lp");
canPower13->cd();
grPowErr13->SetLineColor(getNiceColour(i));
grPowErr13->SetMarkerColor(getNiceColour(i));
grPowErr13->Draw("lp");
}
}
void doTest()
{
TGraph *gr1=getWave("/home/rjn/saltStuff/salt_trip3_data/disk_4/TEK00024.CSV");
TGraph *gr2=getWave("/home/rjn/saltStuff/salt_trip3_data/disk_4/TEK00025.CSV");
Int_t N1=gr1->GetN();
Double_t *x1=gr1->GetX();
Double_t dt1=x1[1]-x1[0];
Int_t peakBin1=FFTtools::getPeakBin(gr1);
// cout << dt1 << "\t" << N1*dt1 << "\n";
Int_t N2=gr2->GetN();
Double_t *x2=gr2->GetX();
Double_t *y2=gr2->GetY();
Double_t dt2=x2[1]-x2[0];
Int_t peakBin2=FFTtools::getPeakBin(gr2);
// cout << dt2 << "\t" << N2*dt2 << "\n";
Double_t firstPoint1=x1[0]-x1[peakBin1];
Double_t lastPoint1=x1[N1-1]-x1[peakBin1];
Int_t newFirstBin2=Int_t(peakBin2+(firstPoint1/dt2));
Int_t newN2=Int_t(TMath::Ceil(peakBin2+lastPoint1/dt2))-newFirstBin2;
TGraph *gr2Zoom = new TGraph(newN2,&(x2[newFirstBin2]),&(y2[newFirstBin2]));
// cout << << "\t" << TMath::Ceil(peakBin2+lastPoint1/dt2) << "\n";
TCanvas *canWave = new TCanvas("canWave","canWave");
canWave->Divide(1,2);
canWave->cd(1);
gr1->SetTitle("Example Pulse -- 251 Samples");
gr1->Draw("al");
gr1->SetLineColor(getNiceColour(0));
canWave->cd(2);
gr2Zoom->SetTitle("Example Pulse -- 126 Samples");
gr2Zoom->Draw("al");
gr2Zoom->SetLineColor(getNiceColour(1));
TGraph *grPower1=FFTtools::makePowerSpectrum(gr1);
TGraph *grPower2=FFTtools::makePowerSpectrum(gr2Zoom);
TCanvas *canPower = new TCanvas("canPower","canPower");
canPower->Divide(1,2);
canPower->cd(1);
grPower1->SetTitle("Unnormalised -- 251 Samples");
grPower1->Draw("al");
grPower1->SetLineColor(getNiceColour(0));
canPower->cd(2);
grPower2->SetTitle("Unnormalised -- 126 Samples");
grPower2->Draw("al");
grPower2->SetLineColor(getNiceColour(1));
cout << sumVoltageSquared(gr1) << "\t" << sumVoltageSquared(gr2Zoom) << "\n";
cout << "Unnormalised\t" << integratePower(grPower1) << "\t" << integratePower(grPower2) << "\n";
TGraph *grPeriod1=FFTtools::makePowerSpectrumPeriodogram(gr1);
TGraph *grPeriod2=FFTtools::makePowerSpectrumPeriodogram(gr2Zoom);
TCanvas *canPeriod = new TCanvas("canPeriod","canPeriod");
canPeriod->Divide(1,2);
canPeriod->cd(1);
grPeriod1->Draw("al");
grPeriod1->SetTitle("Peiodogram -- 251 Samples");
grPeriod1->SetLineColor(getNiceColour(0));
canPeriod->cd(2);
grPeriod2->Draw("al");
grPeriod2->SetTitle("Peiodogram -- 126 Samples");
grPeriod2->SetLineColor(getNiceColour(1));
cout << grPeriod1->GetN() << "\t" << grPeriod2->GetN() << "\n";
cout << sumVoltageSquared(gr1)/gr1->GetN() << "\t" << sumVoltageSquared(gr2Zoom)/gr2Zoom->GetN() << "\n";
cout << integrateVoltageSquared(gr1) << "\t" << integrateVoltageSquared(gr2Zoom) << "\n";
cout << "Periodogram\t" << integratePower(grPeriod1) << "\t" << integratePower(grPeriod2) << "\n";
TGraph *grdB1=FFTtools::makePowerSpectrumVoltsSeconds(gr1);
TGraph *grdB2=FFTtools::makePowerSpectrumVoltsSeconds(gr2Zoom);
TCanvas *candB = new TCanvas("candB","candB");
candB->Divide(1,2);
candB->cd(1);
grdB1->Draw("al");
grdB1->SetTitle("Normalised -- 251 Samples");
grdB1->SetLineColor(getNiceColour(0));
candB->cd(2);
grdB2->SetTitle("Normalised -- 126 Samples");
grdB2->Draw("al");
grdB2->SetLineColor(getNiceColour(1));
// cout << integratePower
TGraph *grdBPadded1=FFTtools::makePowerSpectrumVoltsSecondsPadded(gr1);
TGraph *grdBPadded2=FFTtools::makePowerSpectrumVoltsSecondsPadded(gr2Zoom);
TCanvas *candBPadded = new TCanvas("candBPadded","candBPadded");
candBPadded->Divide(1,2);
candBPadded->cd(1);
grdBPadded1->Draw("al");
grdBPadded1->SetTitle("Normalised -- 251 Samples (x4 Zero Padding)");
grdBPadded1->SetLineColor(getNiceColour(0));
candBPadded->cd(2);
grdBPadded2->SetTitle("Normalised -- 126 Samples (x4 Zero Padding)");
grdBPadded2->Draw("al");
grdBPadded2->SetLineColor(getNiceColour(1));
cout << "Sum\n";
cout << integratePower(grdB1) << "\t" << integratePower(grdB2) << "\n";
cout << integratePower(grdBPadded1) << "\t" << integratePower(grdBPadded2) << "\n";
cout << "Integral\n";
cout << integratePowerProper(grdB1) << "\t" << integratePowerProper(grdB2) << "\n";
cout << integratePowerProper(grdBPadded1) << "\t" << integratePowerProper(grdBPadded2) << "\n";
}
