// ****************************************************************************
//
// Function Name: RWindowView::InvalidateVectorRect( )
//
// Description: Invalidates the given vector rect in this view
//
// Returns: Nothing
//
// Exceptions: None
//
// ****************************************************************************
//
void RWindowView::InvalidateVectorRect( const RRealVectorRect& rect, BOOLEAN fErase )
{
//
// Only invalidate if we have a CWnd
if( !GetCWnd() )
return;
// Get the bounding rect...
RRealRect temp = rect.m_TransformedBoundingRect;
// Get our transformation...
R2dTransform transform;
ApplyTransform( transform, FALSE, FALSE );
// Apply it to our bounds...
temp *= transform;
// Convert the bounds to device units
::LogicalUnitsToDeviceUnits( temp, *this );
// guard for roundoff...
const YRealDimension kRoundOffGuard = 2.0;
temp.Inflate( RRealSize( kRoundOffGuard, kRoundOffGuard ) );
// Put it in a CRect and do the invalidate
CRect crect( ::Round(temp.m_Left), ::Round(temp.m_Top), ::Round(temp.m_Right), ::Round(temp.m_Bottom) );
GetCWnd( ).InvalidateRect( crect, fErase );
}
TBToolTip::TBToolTip(Win *parent, int x, int y, const unicode_t *s)
: Win(Win::WT_POPUP, 0, parent),
text(new_unicode_str(s))
{
wal::GC gc(this);
cpoint p = GetStaticTextExtent(gc, s, GetFont());
Move(crect(x,y,x + p.x + 4, y + p.y + 2));
}
void ToolBar::Paint( wal::GC& gc, const crect& paintRect )
{
crect cr = ClientRect();
crect rect = cr;
unsigned colorBg = UiGetColor( uiBackground, 0, 0, 0x808080 ); //GetColor(0);
unsigned splitColor1 = ColorTone( colorBg, -70 );
unsigned splitColor2 = ColorTone( colorBg, 70 );
if ( g_WcmConfig.styleShow3DUI )
{
Draw3DButtonW2( gc, rect, colorBg, true );
rect.Dec();
rect.Dec();
}
gc.SetFillColor( colorBg );
gc.FillRect( rect );
gc.Set( GetFont() );
int x = 2;
for ( size_t i = 0; i < _list.size(); i++ )
{
Node* p = _list[i].ptr();
if ( p )
{
DrawNode( gc, p, _pressed == p ? DRAW_PRESSED : DRAW_NORMAL );
x += p->rect.Width();
}
else
{
gc.SetFillColor( splitColor1 );
int x1 = x + SPLITTER_WIDTH / 2;
gc.FillRect( crect( x1, rect.top, x1 + 1, rect.bottom ) );
gc.SetFillColor( splitColor2 );
gc.FillRect( crect( x1 + 2, rect.top, x1 + 2, rect.bottom ) );
x += SPLITTER_WIDTH;
}
}
return;
}
static void DrawCE( GC& gc, int x, int y, bool isSet )
{
gc.SetLine( CBC_BOXFRAME );
gc.SetFillColor( CBC_BOX_BG );
gc.Ellipce( crect( x, y, x + 13, y + 13 ) );
if ( isSet )
{
DrawPixelList( gc, rbPix, x + 4, y + 4, CBC_CHECK );
}
}
void ScrollView::adjustScrollbars(int x, int y, bool refresh)
{
wxWindow* win = nativeWindow();
if (!win)
return;
wxRect crect(win->GetClientRect()), vrect(win->GetVirtualSize());
if (x == -1) x = m_data->viewStart.x;
if (y == -1) y = m_data->viewStart.y;
long style = win->GetWindowStyle();
// by setting the wxALWAYS_SHOW_SB wxWindow flag before
// each SetScrollbar call, we can control the scrollbars
// visibility individually.
// horizontal scrollbar
switch (m_data->hScrollbarMode) {
case ScrollbarAlwaysOff:
win->SetWindowStyleFlag(style & ~wxALWAYS_SHOW_SB);
win->SetScrollbar(wxHORIZONTAL, 0, 0, 0, refresh);
break;
case ScrollbarAuto:
win->SetWindowStyleFlag(style & ~wxALWAYS_SHOW_SB);
win->SetScrollbar(wxHORIZONTAL, x, crect.width, vrect.width, refresh);
break;
default: // ScrollbarAlwaysOn
win->SetWindowStyleFlag(style | wxALWAYS_SHOW_SB);
win->SetScrollbar(wxHORIZONTAL, x, crect.width, vrect.width, refresh);
break;
}
// vertical scrollbar
switch (m_data->vScrollbarMode) {
case ScrollbarAlwaysOff:
win->SetWindowStyleFlag(style & ~wxALWAYS_SHOW_SB);
win->SetScrollbar(wxVERTICAL, 0, 0, 0, refresh);
break;
case ScrollbarAlwaysOn:
win->SetWindowStyleFlag(style | wxALWAYS_SHOW_SB);
win->SetScrollbar(wxVERTICAL, y, crect.height, vrect.height, refresh);
break;
default: // case ScrollbarAuto:
win->SetWindowStyleFlag(style & ~wxALWAYS_SHOW_SB);
win->SetScrollbar(wxVERTICAL, y, crect.height, vrect.height, refresh);
}
}
void GUICornerFrame::draw(float dt){
if(!Visible)return;
if(!guiMngr)return;
math::vector2d p=getPos();
math::vector2d sz=getSize();
const math::vector2d cpos[]={
math::vector2d(0,0),
math::vector2d(1,0),
math::vector2d(0,1),
math::vector2d(1,1),
};
math::rectf *pClip=0;
if(getParent())
pClip=&getParent()->getClipRect();
//draw back corners
for(int i=0;i<EC_COUNT;++i)
{
if(Corners[i] && Corners[i]->isFront()==false && Corners[i]->getTexture()){
video::TextureUnit* ctex=Corners[i]->getTexture();
math::vector2d tsz=Corners[i]->getSize();
math::vector2d center=p+sz*cpos[i];
math::rectf crect(center-tsz*0.5f,center+tsz*0.5f);
getDevice()->draw2DImage(crect,ctex,Corners[i]->getColor(),pClip);
}
}
GUIImage::draw(dt);
//draw front corners
for(int i=0;i<EC_COUNT;++i)
{
if(Corners[i] && Corners[i]->isFront()==true && Corners[i]->getTexture()){
video::TextureUnit* ctex=Corners[i]->getTexture();
math::vector2d tsz=Corners[i]->getSize();
math::vector2d center=p+sz*cpos[i];
math::rectf crect(center-tsz*0.5f,center+tsz*0.5f);
getDevice()->draw2DImage(crect,ctex,Corners[i]->getColor(),pClip);
}
}
}
static void DrawCB( GC& gc, int x, int y, bool isSet )
{
gc.SetLine( CBC_BOXFRAME );
gc.MoveTo( x, y );
gc.LineTo( x + 13, y );
gc.LineTo( x + 13, y + 13 );
gc.LineTo( x, y + 13 );
gc.LineTo( x, y );
gc.SetFillColor( CBC_BOX_BG ); //CCC
gc.FillRect( crect( x + 1, y + 1, x + 13, y + 13 ) );
if ( isSet )
{
DrawPixelList( gc, chPix, x + 3, y + 3, CBC_CHECK );
}
}
bool NCDialog::EventShow( bool show )
{
if ( show && Type() == WT_CHILD && Parent() )
{
SetPosition();
crect r = Rect();
_shadow.Move( crect( r.left + 10, r.top + 10, 10 + r.right, 10 + r.bottom ) );
_shadow.Show( SHOW_INACTIVE );
_shadow.OnTop();
}
OnTop();
SetFocus();
return Win::EventShow( show );
}
crect Win::Rect()
{
POINT p;
p.x=0;
p.y=0;
::ClientToScreen((HWND)this->handle, &p);
if (type != WS_POPUP && this->parent)
ScreenToClient(parent->handle, &p);
RECT rect;
::GetClientRect((HWND)handle,&rect);
rect.left=p.x;
rect.top=p.y;
rect.right+=p.x;
rect.bottom+=p.y;
return crect(rect.left, rect.top, rect.right, rect.bottom);
}
void
ControllerHelpWindow::draw()
{
if (!impl->active)
return;
const Rectf& rect = impl->text_area->get_rect().grow(8.0f);
Display::fill_rounded_rect(rect, 16.0f, Color(0.3f, 0.3f, 0.5f, 0.5f));
Display::draw_rounded_rect(rect, 16.0f, Color(1.0f, 1.0f, 1.0f, 0.5f));
impl->text_area->draw();
Controller controller = InputManager::get_controller();
Rectf crect(Vector(rect.right - 100, rect.top - 100 - 8.0f),
Size(100, 100));
Display::fill_rounded_rect(crect, 10.0f, Color(1.0f, 1.0f, 1.0f, 0.2f));
Display::draw_rounded_rect(crect, 10.0f, Color(1.0f, 1.0f, 1.0f, 0.5f));
Vector pos(crect.left + crect.get_width()/2 + controller.get_axis_state(X_AXIS) * (crect.get_width()-16.0f)/2,
crect.top + crect.get_height()/2 + controller.get_axis_state(Y_AXIS) * (crect.get_width()-16.0f)/2);
Display::fill_circle(pos, 10.0f, Color(0.8f, 0, 0));
Display::draw_circle(pos, 10.0f, Color(1.0f, 0, 0));
for(int i = 0; i < 6; ++i)
{
if (controller.get_button_state(i))
{
Display::fill_circle(Vector(crect.left - 16.0f, crect.top + (crect.get_height()-20)/3 * i + 10.0f),
10.0f, Color(0.8f, 0, 0));
Display::draw_circle(Vector(crect.left - 16.0f, crect.top + (crect.get_height()-20)/3 * i + 10.0f),
10.0f, Color(1.0f, 0.0f, 0.0f));
}
else
{
Display::fill_circle(Vector(crect.left - 16.0f, crect.top + (crect.get_height()-20)/3 * i + 10.0f),
10.0f, Color(1.0f, 1.0f, 1.0f, 0.2f));
Display::draw_circle(Vector(crect.left - 16.0f, crect.top + (crect.get_height()-20)/3 * i + 10.0f),
10.0f, Color(1.0f, 1.0f, 1.0f, 0.5f));
}
}
}
crect MenuBar::ItemRect(int n)
{
if (!rectList.count())
{
crect wRect = ClientRect();
GC gc(this);
gc.Set(GetFont());
cpoint chSize = gc.GetTextExtents(ABCString);
int spaceWidth = chSize.x/ABCStringLen;
int x = 1;
for (int i = 0; i<list.count(); i++)
{
cpoint textSize = gc.GetTextExtents(list[i].text.ptr());
int x2 = x + textSize.x + spaceWidth*2 + 2 ;
crect itemRect(x, 1, x2 , wRect.bottom-1);
x = x2;
rectList.append(itemRect);
}
}
return (n<0 || n>=list.count()) ? crect(0,0,0,0): rectList[n];
}
int placement_problem::evaluate_branch(int c1, rect fixed, std::vector<point> const & pos, branching_rule rule) const{
rect crect(pos[c1].x, pos[c1].y, pos[c1].x+cells[c1].width, pos[c1].y+cells[c1].height);
int area = rect::intersection(fixed, crect).get_area();
if(area <= 0) return -1;
if(rule == CMIN or rule == CAVG
or rule == SMIN or rule == SAVG){
auto constraints = get_branching_constraints(c1, fixed);
std::vector<int> res =
(rule == CMIN or rule == CAVG) ?
evaluate_branches_expected(constraints)
: evaluate_branches_strong(constraints);
if(res.size() <= 1) return std::numeric_limits<int>::max();
if(rule == SMIN or rule == CMIN) return *std::min_element(res.begin(), res.end());
else{
int tot=0;
for(int t : res) tot += t;
return tot/res.size();
}
}
else{
return eval_overlap(fixed, crect, rule);
}
}
crect Win::ScreenRect()
{
RECT rect;
::GetWindowRect(handle,&rect);
return crect(rect.left, rect.top, rect.right, rect.bottom);
}
int main(void)
{
static LALStatus status;
LALDetector detector;
LALSource pulsar;
CoarseFitOutput output;
CoarseFitInput input;
CoarseFitParams params;
LIGOTimeGPS tgps[FITTOPULSARTEST_LENGTH];
REAL4 cosIota;
REAL4 phase;
REAL4 psi;
REAL4 h0;
REAL4 cos2phase, sin2phase;
static RandomParams *randomParams;
static REAL4Vector *noise;
INT4 seed = 0;
LALDetAndSource detAndSource;
LALDetAMResponseSeries pResponseSeries = {NULL,NULL,NULL};
REAL4TimeSeries Fp, Fc, Fs;
LALTimeIntervalAndNSample time_info;
UINT4 i;
/* Allocate memory */
input.B = NULL;
input.var = NULL;
LALZCreateVector( &status, &input.B, FITTOPULSARTEST_LENGTH);
LALZCreateVector( &status, &input.var, FITTOPULSARTEST_LENGTH);
noise = NULL;
LALCreateVector( &status, &noise, FITTOPULSARTEST_LENGTH);
LALCreateRandomParams( &status, &randomParams, seed);
Fp.data = NULL;
Fc.data = NULL;
Fs.data = NULL;
pResponseSeries.pPlus = &(Fp);
pResponseSeries.pCross = &(Fc);
pResponseSeries.pScalar = &(Fs);
LALSCreateVector(&status, &(pResponseSeries.pPlus->data), 1);
LALSCreateVector(&status, &(pResponseSeries.pCross->data), 1);
LALSCreateVector(&status, &(pResponseSeries.pScalar->data), 1);
input.t = tgps;
/******** GENERATE FAKE INPUT **********/
time_info.epoch.gpsSeconds = FITTOPULSARTEST_T0;
time_info.epoch.gpsNanoSeconds = 0;
time_info.deltaT = 60;
time_info.nSample = FITTOPULSARTEST_LENGTH;
cosIota = 0.5;
psi = 0.1;
phase = 0.4;
h0 = 5.0;
cos2phase = cos(2.0*phase);
sin2phase = sin(2.0*phase);
detector = lalCachedDetectors[LALDetectorIndexGEO600DIFF]; /* use GEO 600 detector for tests */
pulsar.equatorialCoords.longitude = 1.4653; /* right ascention of pulsar */
pulsar.equatorialCoords.latitude = -1.2095; /* declination of pulsar */
pulsar.equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL; /* coordinate system */
pulsar.orientation = psi; /* polarization angle */
strcpy(pulsar.name, "fakepulsar"); /* name of pulsar */
detAndSource.pDetector = &detector;
detAndSource.pSource = &pulsar;
LALNormalDeviates( &status, noise, randomParams );
LALComputeDetAMResponseSeries(&status, &pResponseSeries, &detAndSource, &time_info);
for (i = 0;i < FITTOPULSARTEST_LENGTH; i++)
{
input.t[i].gpsSeconds = FITTOPULSARTEST_T0 + 60*i;
input.t[i].gpsNanoSeconds = 0;
input.B->data[i] = crect( pResponseSeries.pPlus->data->data[i]*h0*(1.0 + cosIota*cosIota)*cos2phase + 2.0*pResponseSeries.pCross->data->data[i]*h0*cosIota*sin2phase, pResponseSeries.pPlus->data->data[i]*h0*(1.0 + cosIota*cosIota)*sin2phase - 2.0*pResponseSeries.pCross->data->data[i]*h0*cosIota*cos2phase );
input.var->data[i] = crect( noise->data[FITTOPULSARTEST_LENGTH-i-1]*noise->data[FITTOPULSARTEST_LENGTH-i-1], noise->data[i]*noise->data[i] );
}
input.B->length = FITTOPULSARTEST_LENGTH;
input.var->length = FITTOPULSARTEST_LENGTH;
/******* TEST RESPONSE TO VALID DATA ************/
/* Test that valid data generate the correct answers */
params.detector = detector;
params.pulsarSrc = pulsar;
params.meshH0[0] = 4.0;
params.meshH0[1] = 0.2;
params.meshH0[2] = 10;
params.meshCosIota[0] = 0.0;
params.meshCosIota[1] = 0.1;
params.meshCosIota[2] = 10;
params.meshPhase[0] = 0.0;
params.meshPhase[1] = 0.1;
params.meshPhase[2] = 10;
params.meshPsi[0] = 0.0;
params.meshPsi[1] = 0.1;
params.meshPsi[2] = 10;
output.mChiSquare = NULL;
LALDCreateVector( &status, &output.mChiSquare,params.meshH0[2]*params.meshCosIota[2]*params.meshPhase[2]*params.meshPsi[2]);
LALCoarseFitToPulsar(&status,&output, &input, ¶ms);
if(status.statusCode)
{
printf("Unexpectedly got error code %d and message %s\n",
status.statusCode, status.statusDescription);
return FITTOPULSARTESTC_EFLS;
}
if(output.phase > phase + params.meshPhase[2] || output.phase < phase - params.meshPhase[2])
{
printf("Got incorrect phase %f when expecting %f \n",
output.phase, phase);
return FITTOPULSARTESTC_EFLS;
}
if(output.cosIota > cosIota + params.meshCosIota[2] || output.cosIota < cosIota - params.meshCosIota[2])
{
printf("Got incorrect cosIota %f when expecting %f \n",
output.cosIota, cosIota);
return FITTOPULSARTESTC_EFLS;
}
if(output.psi > psi + params.meshPsi[2] || output.psi < psi - params.meshPsi[2])
{
printf("Got incorrect psi %f when expecting %f \n",
output.psi, psi);
return FITTOPULSARTESTC_EFLS;
}
/******* TEST RESPONSE OF LALCoarseFitToPulsar TO INVALID DATA ************/
#ifndef LAL_NDEBUG
if ( ! lalNoDebug ) {
/* Test that all the error conditions are correctly detected by the function */
LALCoarseFitToPulsar(&status, NULL, &input, ¶ms);
if (status.statusCode != FITTOPULSARH_ENULLOUTPUT
|| strcmp(status.statusDescription, FITTOPULSARH_MSGENULLOUTPUT))
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription);
printf( "Expected error code %d and message %s\n",
FITTOPULSARH_ENULLOUTPUT, FITTOPULSARH_MSGENULLOUTPUT);
return FITTOPULSARTESTC_ECHK;
}
LALCoarseFitToPulsar(&status, &output, NULL, ¶ms);
if (status.statusCode != FITTOPULSARH_ENULLINPUT
|| strcmp(status.statusDescription, FITTOPULSARH_MSGENULLINPUT))
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription);
printf( "Expected error code %d and message %s\n",
FITTOPULSARH_ENULLINPUT, FITTOPULSARH_MSGENULLINPUT);
return FITTOPULSARTESTC_ECHK;
}
LALCoarseFitToPulsar(&status, &output, &input, NULL);
if (status.statusCode != FITTOPULSARH_ENULLPARAMS
|| strcmp(status.statusDescription, FITTOPULSARH_MSGENULLPARAMS))
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription);
printf( "Expected error code %d and message %s\n",
FITTOPULSARH_ENULLPARAMS, FITTOPULSARH_MSGENULLPARAMS);
return FITTOPULSARTESTC_ECHK;
}
/* try having two input vectors of different length */
input.var->length = 1;
LALCoarseFitToPulsar(&status, &output, &input, ¶ms);
if (status.statusCode != FITTOPULSARH_EVECSIZE
|| strcmp(status.statusDescription, FITTOPULSARH_MSGEVECSIZE))
{
printf( "Got error code %d and message %s\n",
status.statusCode, status.statusDescription);
printf( "Expected error code %d and message %s\n",
FITTOPULSARH_EVECSIZE, FITTOPULSARH_MSGEVECSIZE);
return FITTOPULSARTESTC_ECHK;
}
input.var->length = FITTOPULSARTEST_LENGTH;
} /* if ( ! lalNoDebug ) */
#endif /* LAL_NDEBUG */
/******* CLEAN UP ************/
LALZDestroyVector(&status, &input.B);
LALZDestroyVector(&status, &input.var);
LALDestroyVector(&status, &noise);
LALDDestroyVector(&status, &output.mChiSquare);
LALDestroyRandomParams(&status, &randomParams);
LALSDestroyVector(&status, &(pResponseSeries.pPlus->data));
LALSDestroyVector(&status, &(pResponseSeries.pCross->data));
LALSDestroyVector(&status, &(pResponseSeries.pScalar->data));
LALCheckMemoryLeaks();
return FITTOPULSARTESTC_ENOM;
}
void clSelectDriveDlgMenu::Paint( wal::GC& gc, const crect& paintRect )
{
cfont* font = GetFont();
gc.Set( font );
int y = 0;
int bgColor = UiGetColor( uiBackground, 0, 0, 0xB0B000 );
int count = _data->Count();
int Splitters = 0;
int SplitterTop = 0;
int SplitterBottom = 0;
for ( int i = 0; i < count; i++ )
{
if ( _data->list[i].cmd == 0 )
{
gc.SetFillColor( bgColor );
gc.FillRect( crect( 0, y, _width, y + _splitterH ) );
crect rect( 0, y + 1, 0 + _width, y + 2 );
gc.SetFillColor( ColorTone( bgColor, -150 ) );
gc.FillRect( rect );
rect.top += 1;
rect.bottom += 1;
gc.SetFillColor( ColorTone( bgColor, +50 ) );
gc.FillRect( rect );
y += _splitterH;
Splitters++;
if ( Splitters == 1 ) { SplitterTop = y; }
if ( Splitters == 2 ) { SplitterBottom = y - _splitterH; }
}
else
{
UiCondList ucl;
if ( i == _current ) { ucl.Set( uiCurrentItem, true ); }
unsigned bg = UiGetColor( uiBackground, uiItem, &ucl, 0xFFFFFF );
unsigned textColor = UiGetColor( uiColor, uiItem, &ucl, 0 );
unsigned fcColor = UiGetColor( uiFcColor, uiItem, &ucl, 0xFF );
unsigned commentColor = UiGetColor( uiCommentColor, uiItem, &ucl, 0 );
gc.SetFillColor( bg );
gc.FillRect( crect( 0, y, _width, y + _itemH ) );
cicon icon;
if ( _data->list[i].icon >= 0 )
{
icon.Load( _data->list[i].icon, 16, 16 );
}
else
{
icon.Load( _data->list[i].cmd, 16, 16 );
}
gc.DrawIcon( 0, y, &icon );
gc.SetTextColor( textColor );
int x = 16 + 5;
const unicode_t* name = _data->list[i].name.data();
const unicode_t* comment1 = _data->list[i].comment1.data();
const unicode_t* comment2 = _data->list[i].comment2.data();
if ( name )
{
gc.TextOutF( x, y, name );
gc.SetTextColor( fcColor );
gc.TextOutF( x, y, name, 1 );
}
if ( comment1 )
{
gc.SetTextColor( commentColor );
gc.TextOutF( x + _nameW + 5, y, comment1 );
}
if ( comment2 )
{
gc.SetTextColor( commentColor );
gc.TextOutF( x + _nameW + 5 + _comment1W + 30, y, comment2 );
}
y += _itemH;
}
}
if ( _comment2W && SplitterTop && SplitterBottom )
{
int cx = _nameW + 5 + _comment1W + 30;
gc.SetFillColor( ColorTone( bgColor, -150 ) );
gc.FillRect( crect( cx, SplitterTop, cx + _splitterW, SplitterBottom ) );
}
}
void K3b::FillStatusDisplayWidget::paintEvent( QPaintEvent* )
{
QPainter p( this );
const QPalette::ColorGroup colorGroup = isEnabled() ? QPalette::Normal : QPalette::Disabled;
const Msf docSize = d->doc->length();
const Msf cdSize = d->cdSize;
const Msf maxValue = (cdSize > docSize ? cdSize : docSize) + ( 10*60*75 );
const Msf tolerance = 60*75;
QBrush fillBrush;
if( docSize <= cdSize - tolerance ) {
fillBrush = KColorScheme( colorGroup, KColorScheme::Selection ).background( KColorScheme::PositiveBackground );
}
else if( docSize > cdSize + tolerance ) {
fillBrush = KColorScheme( colorGroup, KColorScheme::Selection ).background( KColorScheme::NegativeBackground );
}
else {
fillBrush = KColorScheme( colorGroup, KColorScheme::Selection ).background( KColorScheme::NeutralBackground );
}
const QPen normalPen = KColorScheme( colorGroup, KColorScheme::Window ).foreground( KColorScheme::NormalText ).color();
const QPen fillPen = KColorScheme( colorGroup, KColorScheme::Selection ).foreground( KColorScheme::NormalText ).color();
QStyleOptionProgressBarV2 sopb;
sopb.direction = layoutDirection();
sopb.fontMetrics = fontMetrics();
sopb.palette = palette();
sopb.palette.setBrush( QPalette::Highlight, fillBrush );
sopb.rect = rect();
sopb.state = isEnabled() ? QStyle::State_Enabled : QStyle::State_None;
sopb.minimum = 0;
sopb.maximum = maxValue.totalFrames();
sopb.progress = docSize.totalFrames();
style()->drawControl( QStyle::CE_ProgressBar, &sopb, &p );
const QRect barRect = style()->subElementRect( QStyle::SE_ProgressBarContents, &sopb );
// so split width() in maxValue pieces
double one = (double)barRect.width() / (double)maxValue.totalFrames();
QRect crect( barRect );
crect.setWidth( (int)(one*(double)docSize.totalFrames()) );
// ====================================================================================
// Now the colored bar is painted
// Continue with the texts
// ====================================================================================
// first we determine the text to display
// ====================================================================================
QString docSizeText;
if( d->showTime )
docSizeText = i18n("%1 min", d->doc->length().toString(false));
else
docSizeText = KIO::convertSize( d->doc->size() );
QString overSizeText;
if( d->cdSize.mode1Bytes() >= d->doc->size() )
overSizeText = i18n("Available: %1 of %2",
d->showTime
? i18n("%1 min", (cdSize - d->doc->length()).toString(false) )
: KIO::convertSize( (cdSize - d->doc->length()).mode1Bytes() ),
d->showTime
? i18n("%1 min", cdSize.toString(false))
: KIO::convertSize( cdSize.mode1Bytes() ) );
else
overSizeText = i18n("Capacity exceeded by %1",
d->showTime
? i18n("%1 min", (d->doc->length() - cdSize ).toString(false))
: KIO::convertSize( (long long)d->doc->size() - cdSize.mode1Bytes() ) );
// ====================================================================================
// calculate the medium size marker
// ====================================================================================
int mediumSizeMarkerPos = barRect.left() + (int)(one*cdSize.lba());
QPoint mediumSizeMarkerFrom( mediumSizeMarkerPos, barRect.bottom() );
QPoint mediumSizeMarkerTo( mediumSizeMarkerPos, barRect.top() + barRect.height()/2 );
// ====================================================================================
// we want to draw the docSizeText centered in the filled area
// if there is not enough space we just align it left
// ====================================================================================
int docSizeTextPos = 0;
int docSizeTextLength = fontMetrics().width(docSizeText);
if( docSizeTextLength + 5 > crect.width() ) {
docSizeTextPos = crect.left() + 5; // a little margin
}
else {
docSizeTextPos = ( crect.width() - docSizeTextLength ) / 2;
// make sure the text does not cross the medium size marker
if( docSizeTextPos <= mediumSizeMarkerPos && mediumSizeMarkerPos <= docSizeTextPos + docSizeTextLength )
docSizeTextPos = qMax( crect.left() + 5, mediumSizeMarkerPos - docSizeTextLength - 5 );
}
// ====================================================================================
// calculate the over size text
// ====================================================================================
QFont overSizeFont(font());
overSizeFont.setPointSize( qMax( 8, overSizeFont.pointSize()-4 ) );
overSizeFont.setBold(false);
QRect overSizeTextRect( barRect );
int overSizeTextLength = QFontMetrics(overSizeFont).width(overSizeText);
if( overSizeTextLength + 5 > overSizeTextRect.width() - (int)(one*cdSize.totalFrames()) ) {
// we don't have enough space on the right, so we paint to the left of the line
overSizeTextRect.setLeft( (int)(one*cdSize.totalFrames()) - overSizeTextLength - 5 );
}
else {
overSizeTextRect.setLeft( mediumSizeMarkerPos + 5 );
}
// make sure the two text do not overlap (this does not cover all cases though)
if( overSizeTextRect.left() < docSizeTextPos + docSizeTextLength )
docSizeTextPos = qMax( crect.left() + 5, qMin( overSizeTextRect.left() - docSizeTextLength - 5, mediumSizeMarkerPos - docSizeTextLength - 5 ) );
QRect docTextRect( barRect );
docTextRect.setLeft( docSizeTextPos );
// Draw the fill part
p.setPen( fillPen );
p.setClipRect( QStyle::visualRect( layoutDirection(), barRect, crect ) );
p.drawLine( QStyle::visualPos( layoutDirection(), barRect, mediumSizeMarkerFrom ),
QStyle::visualPos( layoutDirection(), barRect, mediumSizeMarkerTo ) );
p.drawText( QStyle::visualRect( layoutDirection(), barRect, docTextRect ),
QStyle::visualAlignment( layoutDirection(), Qt::AlignLeft | Qt::AlignVCenter ), docSizeText );
p.setFont(overSizeFont);
p.drawText( QStyle::visualRect( layoutDirection(), barRect, overSizeTextRect ),
QStyle::visualAlignment( layoutDirection(), Qt::AlignLeft | Qt::AlignVCenter ), overSizeText );
// Draw the remain part
p.setPen( normalPen );
p.setClipRect( QStyle::visualRect( layoutDirection(), barRect,
QRect( crect.right(), barRect.top(), barRect.width()-crect.width(), barRect.height() ) ) );
p.drawLine( QStyle::visualPos( layoutDirection(), barRect, mediumSizeMarkerFrom ),
QStyle::visualPos( layoutDirection(), barRect, mediumSizeMarkerTo ) );
p.setFont( font() );
p.drawText( QStyle::visualRect( layoutDirection(), barRect, docTextRect ),
QStyle::visualAlignment( layoutDirection(), Qt::AlignLeft | Qt::AlignVCenter ), docSizeText );
p.setFont(overSizeFont);
p.drawText( QStyle::visualRect( layoutDirection(), barRect, overSizeTextRect ),
QStyle::visualAlignment( layoutDirection(), Qt::AlignLeft | Qt::AlignVCenter ), overSizeText );
// ====================================================================================
}
REAL4 *array;
const TestSubRecord *sub;
} TestRecord;
REAL4 testarray[3][1824] = { { 0 }, { 0 }, { 0 } };
const TestSubRecord testsub[3][2] = {
{ { .n=0, .v=1.23, .desc="A1", .idx = 3 }, { .n=1, .v=2.34, .desc="X9", .idx = LAL_UINT8_MAX >> 0 } },
{ { .n=0, .v=3.45, .desc="B3", .idx = 7 }, { .n=1, .v=4.56, .desc="Y7", .idx = LAL_UINT8_MAX >> 1 } },
{ { .n=0, .v=5.67, .desc="C5", .idx = 11 }, { .n=1, .v=6.78, .desc="Z5", .idx = LAL_UINT8_MAX >> 5 } },
};
const TestRecord testtable[3] = {
{
.index=3, .flag=1, .name="CasA", .epoch={123456789, 5}, .pos={.sky=5.4321, .freq=100.999, .fkdot={1e-9, 5e-20}}, .values={13.24, 43.234},
.phasef=crectf( 1.2, 3.4 ), .phase=crect( 4.5, 0.2 ), .array=testarray[0], .sub=testsub[0]
},
{
.index=2, .flag=0, .name="Vela", .epoch={452456245, 9}, .pos={.sky=34.454, .freq=1345.34, .fkdot={2e-8, 6e-21}}, .values={14.35, 94.128},
.phasef=crectf( 3.6, 9.3 ), .phase=crect( 8.3, 4.0 ), .array=testarray[1], .sub=testsub[1]
},
{
.index=1, .flag=1, .name="Crab", .epoch={467846774, 4}, .pos={.sky=64.244, .freq=15.6463, .fkdot={4e-6, 0}}, .values={153.4, 3.0900},
.phasef=crectf( 6.7, 4.4 ), .phase=crect( 5.6, 6.3 ), .array=testarray[2], .sub=testsub[2]
},
};
int main( int argc, char *argv[] )
{
// Initialise test array data
int main( void )
{
static LALStatus status;
REAL4Sequence *sSequenceIn;
REAL4Sequence *sSequenceOut;
REAL8Sequence *dSequenceIn;
REAL8Sequence *dSequenceOut;
COMPLEX8Sequence *cSequenceIn;
COMPLEX8Sequence *cSequenceOut;
COMPLEX16Sequence *zSequenceIn;
COMPLEX16Sequence *zSequenceOut;
REAL4FrequencySeries sFrequencySeries;
REAL8FrequencySeries dFrequencySeries;
COMPLEX8FrequencySeries cFrequencySeries;
COMPLEX16FrequencySeries zFrequencySeries;
REAL4FrequencySeries sFrequencySeries2;
REAL8FrequencySeries dFrequencySeries2;
COMPLEX8FrequencySeries cFrequencySeries2;
COMPLEX16FrequencySeries zFrequencySeries2;
REAL4TimeSeries sTimeSeries;
REAL8TimeSeries dTimeSeries;
COMPLEX8TimeSeries cTimeSeries;
COMPLEX16TimeSeries zTimeSeries;
REAL4TimeSeries sTimeSeries2;
REAL8TimeSeries dTimeSeries2;
COMPLEX8TimeSeries cTimeSeries2;
COMPLEX16TimeSeries zTimeSeries2;
REAL4 *sData;
REAL8 *dData;
COMPLEX8 *cData;
COMPLEX16 *zData;
/* Boolean Vars */
BOOLEAN unitComp;
/* variables for units */
RAT4 raise;
LALUnit strainToMinus2;
LALUnit adcToMinus2;
LALUnit adcStrain;
/* This routine should generate a file with data */
/* to be read by ReadFTSeries.c*/
LIGOTimeGPS t;
UINT4 i;
/* Data Test Variable */
UINT4 j;
fprintf(stderr,"Testing value of LALUnitTextSize ... ");
if ( (int)LALSupportUnitTextSize != (int)LALUnitTextSize )
{
fprintf(stderr,"UnitTextSize mismatch: [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
fprintf(stderr,"PASS\n");
t.gpsSeconds = 0;
t.gpsNanoSeconds = 0;
fprintf(stderr,"Testing Print/Read COMPLEX8FrequencySeries ... ");
cSequenceIn = NULL;
LALCCreateVector(&status, &cSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, cData=cSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, cData++ )
{
*(cData) = crectf( i, i+1 );
}
strncpy(cFrequencySeries.name,"Complex frequency series",LALNameLength);
cFrequencySeries.sampleUnits = lalHertzUnit;
cFrequencySeries.deltaF = 1;
cFrequencySeries.epoch = t;
cFrequencySeries.f0 = 5;
cFrequencySeries.data = cSequenceIn;
LALCPrintFrequencySeries(&cFrequencySeries, "cFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
cSequenceOut = NULL;
LALCCreateVector( &status, &cSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
cFrequencySeries2.data = cSequenceOut;
LALCReadFrequencySeries(&status, &cFrequencySeries2, "./cFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(cFrequencySeries.deltaF - cFrequencySeries.deltaF)/
cFrequencySeries.deltaF > READFTSERIESTEST_TOL)
{
fprintf(stderr,"DeltaF MisMatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(cFrequencySeries.name,cFrequencySeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cFrequencySeries.epoch.gpsSeconds) !=
(cFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Second Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cFrequencySeries.epoch.gpsNanoSeconds) !=
(cFrequencySeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch NanosecondMismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cFrequencySeries.f0) ?
(fabs(cFrequencySeries.f0 - cFrequencySeries2.f0)/cFrequencySeries.f0) :
(fabs(cFrequencySeries.f0 - cFrequencySeries2.f0) >
READFTSERIESTEST_TOL))
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&cFrequencySeries.sampleUnits,&cFrequencySeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < cSequenceIn->length;j++)
{
if ((crealf(cSequenceIn->data[j]) ?
fabs((crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))
/crealf(cSequenceIn->data[j]))
:fabs(crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cimagf(cSequenceIn->data[j]) ?
fabs((cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))
/cimagf(cSequenceIn->data[j]))
:fabs(cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read COMPLEX16FrequencySeries ... ");
/* Test case 2 */
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
zSequenceIn = NULL;
LALZCreateVector( &status, &zSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, zData=zSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, zData++ )
{
*(zData) = crect( i/4.0, (i+1)/5.0 );
}
zFrequencySeries.sampleUnits = lalDimensionlessUnit;
strncpy(zFrequencySeries.name,"Complex frequency series",LALNameLength);
zFrequencySeries.deltaF = 1.3;
zFrequencySeries.epoch = t;
zFrequencySeries.f0 = 0;
zFrequencySeries.data = zSequenceIn;
LALZPrintFrequencySeries(&zFrequencySeries, "zFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
zSequenceOut = NULL;
LALZCreateVector( &status, &zSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
zFrequencySeries2.data = zSequenceOut;
LALZReadFrequencySeries(&status, &zFrequencySeries2, "./zFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if ((zFrequencySeries.deltaF) != (zFrequencySeries2.deltaF))
{
fprintf(stderr,"DeltaF Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(zFrequencySeries.name,zFrequencySeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((zFrequencySeries.epoch.gpsSeconds) !=
(zFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((zFrequencySeries.epoch.gpsNanoSeconds) !=
(zFrequencySeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (zFrequencySeries.f0 ?
(fabs(zFrequencySeries.f0 - zFrequencySeries2.f0)/zFrequencySeries.f0)
: (fabs(zFrequencySeries.f0 - zFrequencySeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&zFrequencySeries.sampleUnits,&zFrequencySeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < zSequenceIn->length;j++)
{
if ((creal(zSequenceIn->data[j]) ?
fabs((creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))
/creal(zSequenceIn->data[j])) :
fabs(creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cimag(zSequenceIn->data[j]) ?
fabs((cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))
/cimag(zSequenceIn->data[j])) :
fabs(cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read REAL8FrequencySeries ... ");
/* Test case 3 */
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
dSequenceIn = NULL;
LALDCreateVector( &status, &dSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, dData=dSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, dData++ )
{
*(dData) = 0.005;
}
strncpy(dFrequencySeries.name,"Complex frequency series",LALNameLength);
/* set units */
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&dFrequencySeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dFrequencySeries.deltaF = 1.3;
dFrequencySeries.epoch = t;
dFrequencySeries.f0 = 0;
dFrequencySeries.data = dSequenceIn;
LALDPrintFrequencySeries(&dFrequencySeries, "dFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dSequenceOut = NULL;
LALDCreateVector( &status, &dSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dFrequencySeries2.data = dSequenceOut;
LALDReadFrequencySeries(&status, &dFrequencySeries2, "./dFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if ((dFrequencySeries.deltaF) != (dFrequencySeries.deltaF))
{
fprintf(stderr,"DeltaF Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(dFrequencySeries.name,dFrequencySeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((dFrequencySeries.epoch.gpsSeconds)
!= (dFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((dFrequencySeries.epoch.gpsSeconds)
!= (dFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (dFrequencySeries.f0 ?
(fabs(dFrequencySeries.f0 - dFrequencySeries2.f0)/dFrequencySeries.f0)
: (fabs(dFrequencySeries.f0 - dFrequencySeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&dFrequencySeries.sampleUnits,&dFrequencySeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < dSequenceIn->length;j++)
{
if ((dSequenceIn->data[j] ?
fabs((dSequenceIn->data[j] - dSequenceOut->data[j])
/dSequenceIn->data[j])
:fabs(dSequenceIn->data[j] - dSequenceOut->data[j])) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read REAL4FrequencySeries ... ");
/* Test case 4 */
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
sSequenceIn = NULL;
LALSCreateVector( &status, &sSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, sData=sSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, sData++ )
{
*(sData) = 0.005;
}
strncpy(sFrequencySeries.name,"Complex frequency series",LALNameLength);
/* set units */
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&sFrequencySeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
sFrequencySeries.deltaF = 1.3;
sFrequencySeries.epoch = t;
sFrequencySeries.f0 = 5;
sFrequencySeries.data = sSequenceIn;
sSequenceOut = NULL;
LALSCreateVector( &status, &sSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
sFrequencySeries2.data = sSequenceOut;
LALSPrintFrequencySeries(&sFrequencySeries, "sFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSReadFrequencySeries(&status, &sFrequencySeries2, "./sFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(sFrequencySeries.deltaF - sFrequencySeries2.deltaF)
/sFrequencySeries.deltaF > READFTSERIESTEST_TOL)
{
fprintf(stderr,"Deltaf Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(sFrequencySeries.name,sFrequencySeries2.name)!=0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((sFrequencySeries.epoch.gpsSeconds) !=
(sFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((sFrequencySeries.epoch.gpsNanoSeconds) !=
(sFrequencySeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (sFrequencySeries.f0 ?
(fabs(sFrequencySeries.f0 - sFrequencySeries2.f0)/sFrequencySeries.f0)
: (fabs(sFrequencySeries.f0 - sFrequencySeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&sFrequencySeries.sampleUnits,&sFrequencySeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < sSequenceIn->length;j++)
{
if ((sSequenceIn->data[j] ?
fabs((sSequenceIn->data[j] - sSequenceOut->data[j])
/sSequenceIn->data[j])
:fabs(sSequenceIn->data[j] - sSequenceOut->data[j])) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
LALCDestroyVector(&status, &cSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALCDestroyVector(&status, &cSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALZDestroyVector(&status, &zSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALZDestroyVector(&status, &zSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALDDestroyVector(&status, &dSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALDDestroyVector(&status, &dSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSDestroyVector(&status, &sSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSDestroyVector(&status, &sSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read REAL4TimeSeries ... ");
/* Here is where testing for ReadTimeSeries is done */
/* S Case ReadTimeSeries */
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&sTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
sSequenceIn = NULL;
LALSCreateVector( &status, &sSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, sData=sSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, sData++ )
{
*(sData) = 0.005;
}
strncpy(sTimeSeries.name,"Real4 Time series",LALNameLength);
sTimeSeries.deltaT = 1.3;
sTimeSeries.epoch = t;
sTimeSeries.data = sSequenceIn;
sTimeSeries.f0 = 5;
LALSPrintTimeSeries(&sTimeSeries, "sTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
sSequenceOut = NULL;
LALSCreateVector( &status, &sSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
sTimeSeries2.data = sSequenceOut;
LALSReadTimeSeries(&status, &sTimeSeries2, "./sTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(sTimeSeries.deltaT-sTimeSeries2.deltaT) /
sTimeSeries.deltaT > READFTSERIESTEST_TOL)
{
fprintf(stderr,"DeltaT Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(sFrequencySeries.name,sFrequencySeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((sTimeSeries.epoch.gpsSeconds) != (sTimeSeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((sTimeSeries.epoch.gpsNanoSeconds) != (sTimeSeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
/* printf("%f ... %f f0 value\n",sTimeSeries.f0,sTimeSeries2.f0);*/
if (sTimeSeries.f0 ?
(fabs(sTimeSeries.f0 - sTimeSeries2.f0)/sTimeSeries.f0)
: (fabs(sTimeSeries.f0 - sTimeSeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&sTimeSeries.sampleUnits,&sTimeSeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < sSequenceIn->length;j++)
{
if ((sSequenceIn->data[j] ?
fabs((sSequenceIn->data[j] - sSequenceOut->data[j])
/sSequenceIn->data[j])
:fabs(sSequenceIn->data[j] - sSequenceOut->data[j])) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read COMPLEX16TimeSeries ... ");
/* Z case ReadTimeSeries*/
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&zTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
zSequenceIn = NULL;
LALZCreateVector( &status, &zSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, zData=zSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, zData++ )
{
*(zData) = crect( 0.005, 1 );
}
strncpy(zTimeSeries.name,"Complex16 Time series",LALNameLength);
zTimeSeries.deltaT = 1.3;
zTimeSeries.epoch = t;
zTimeSeries.data = zSequenceIn;
zTimeSeries.f0 = 0;
LALZPrintTimeSeries(&zTimeSeries, "zTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
zSequenceOut = NULL;
LALZCreateVector( &status, &zSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
zTimeSeries2.data = zSequenceOut;
LALZReadTimeSeries(&status, &zTimeSeries2, "./zTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(zTimeSeries.deltaT) - (zTimeSeries2.deltaT)/zTimeSeries.deltaT >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Mismatch DeltaT [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(zTimeSeries.name,zTimeSeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((zTimeSeries.epoch.gpsSeconds) != (zTimeSeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Second Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ( (zTimeSeries.epoch.gpsNanoSeconds)
!= (zTimeSeries2.epoch.gpsNanoSeconds) )
{
fprintf(stderr,"Epoch Nanosecond Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (zTimeSeries.f0 ?
(fabs(zTimeSeries.f0 - zTimeSeries2.f0)/zTimeSeries.f0)
: (fabs(zTimeSeries.f0 - zTimeSeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&zTimeSeries.sampleUnits,&zTimeSeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFUN;
}
for (j = 0; j < zSequenceIn->length;j++)
{
if ((creal(zSequenceIn->data[j]) ?
fabs((creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))
/creal(zSequenceIn->data[j]))
:fabs(creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cimag(zSequenceIn->data[j]) ?
fabs((cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))
/cimag(zSequenceIn->data[j]))
:fabs(cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read REAL8TimeSeries ... ");
/* D case ReadTimeSeries*/
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&sTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
strncpy(dTimeSeries.name,"REAL8 Time series",LALNameLength);
dTimeSeries.sampleUnits = lalHertzUnit;
t.gpsSeconds = 4578;
t.gpsNanoSeconds = 890634;
dSequenceIn = NULL;
LALDCreateVector( &status, &dSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, dData=dSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, dData++ )
{
*(dData) = 0.005;
}
dTimeSeries.deltaT = 1.3;
dTimeSeries.epoch = t;
dTimeSeries.data = dSequenceIn;
dTimeSeries.f0 = 0;
LALDPrintTimeSeries(&dTimeSeries, "dTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dSequenceOut = NULL;
LALDCreateVector( &status, &dSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dTimeSeries2.data = dSequenceOut;
LALDReadTimeSeries(&status, &dTimeSeries2, "./dTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(dTimeSeries.deltaT) - (dTimeSeries2.deltaT)/dTimeSeries.deltaT
> READFTSERIESTEST_TOL)
{
fprintf(stderr,"DeltaT Mismatch [ReadFTSeriesTest:%d,%s]\n",status.statusCode,
status.statusDescription );
return READFTSERIESTESTC_EFLS;
}
if (strcmp(dTimeSeries.name,dTimeSeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%d,%s]\n",status.statusCode,
status.statusDescription );
return READFTSERIESTESTC_EFLS;
}
if ((dTimeSeries.epoch.gpsSeconds) != (dTimeSeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((dTimeSeries.epoch.gpsNanoSeconds)
!= (dTimeSeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch Nanoseconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (dTimeSeries.f0 ?
(fabs(dTimeSeries.f0 - dTimeSeries2.f0)/dTimeSeries.f0)
: (fabs(dTimeSeries.f0 - dTimeSeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&dTimeSeries.sampleUnits,&dTimeSeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < dSequenceIn->length;j++)
{
if ((dSequenceIn->data[j] ?
fabs((dSequenceIn->data[j] - dSequenceOut->data[j])
/dSequenceIn->data[j])
:fabs(dSequenceIn->data[j] - dSequenceOut->data[j])) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read COMPLEX8TimeSeries ... ");
/* C case ReadTimeSeries*/
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&cTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
cSequenceIn = NULL;
LALCCreateVector( &status, &cSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, cData=cSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, cData++ )
{
*(cData) = crectf( 0.005, 1 );
}
strncpy(cTimeSeries.name,"Complex8 Time series",LALNameLength);
cTimeSeries.deltaT = 1.3;
cTimeSeries.epoch = t;
cTimeSeries.data = cSequenceIn;
cTimeSeries.f0 = 0;
cSequenceOut = NULL;
LALCPrintTimeSeries(&cTimeSeries, "cTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALCCreateVector( &status, &cSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
cTimeSeries2.data = cSequenceOut;
LALCReadTimeSeries(&status, &cTimeSeries2, "./cTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(cTimeSeries.deltaT - cTimeSeries2.deltaT)/cTimeSeries.deltaT
> READFTSERIESTEST_TOL)
{
fprintf(stderr,"DeltaT Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(cTimeSeries.name,cTimeSeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cTimeSeries.epoch.gpsSeconds) != (cTimeSeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cTimeSeries.epoch.gpsNanoSeconds)!=(cTimeSeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch Nanoseconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (cTimeSeries.f0 ?
(fabs(cTimeSeries.f0 - cTimeSeries2.f0)/cTimeSeries.f0)
: (fabs(cTimeSeries.f0 - cTimeSeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&cTimeSeries.sampleUnits,&cTimeSeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < cSequenceIn->length;j++)
{
if ((crealf(cSequenceIn->data[j]) ?
fabs((crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))
/crealf(cSequenceIn->data[j]))
:fabs(crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cimagf(cSequenceIn->data[j]) ?
fabs((cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))
/cimagf(cSequenceIn->data[j]))
:fabs(cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
/* *******************Deallocate all memory****************** */
LALCDestroyVector(&status, &cSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALCDestroyVector(&status, &cSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALZDestroyVector(&status, &zSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALZDestroyVector(&status, &zSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALDDestroyVector(&status, &dSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALDDestroyVector(&status, &dSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSDestroyVector(&status, &sSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSDestroyVector(&status, &sSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALCheckMemoryLeaks();
fprintf(stderr,"ReadFTSeries passed all tests.\n");
return READFTSERIESTESTC_ENOM;
}
int main(int argc, char *argv[])
{
UserVariables_t XLAL_INIT_DECL(uvar);
XLAL_CHECK ( InitUserVars(&uvar, argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
MultiLALDetector *detectors = NULL;
XLAL_CHECK( (detectors = XLALMalloc(sizeof(MultiLALDetector))) != NULL, XLAL_ENOMEM );
detectors->length = uvar.IFO->length;
for (UINT4 ii=0; ii<detectors->length; ii++) {
if (strcmp("H1", uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_LHO_4K_DETECTOR]; //H1
} else if (strcmp("L1",uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_LLO_4K_DETECTOR]; //L1
} else if (strcmp("V1", uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_VIRGO_DETECTOR]; //V1
} else if (strcmp("H2", uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_LHO_2K_DETECTOR]; //H2
} else if (strcmp("H2r", uvar.IFO->data[ii])==0) {
LALDetector H2 = lalCachedDetectors[LAL_LHO_2K_DETECTOR]; //H2 rotated
H2.frDetector.xArmAzimuthRadians -= 0.25*LAL_PI;
H2.frDetector.yArmAzimuthRadians -= 0.25*LAL_PI;
memset(&(H2.frDetector.name), 0, sizeof(CHAR)*LALNameLength);
snprintf(H2.frDetector.name, LALNameLength, "%s", "LHO_2k_rotatedPiOver4");
XLAL_CHECK( (XLALCreateDetector(&(detectors->sites[ii]), &(H2.frDetector), LALDETECTORTYPE_IFODIFF)) != NULL, XLAL_EFUNC );
} else {
XLAL_ERROR(XLAL_EINVAL, "Not using valid interferometer! Expected 'H1', 'H2', 'H2r' (rotated H2), 'L1', or 'V1' not %s.\n", uvar.IFO->data[ii]);
}
}
EphemerisData *edat = NULL;
XLAL_CHECK( (edat = XLALInitBarycenter(uvar.ephemEarth, uvar.ephemSun)) != NULL, XLAL_EFUNC );
LIGOTimeGPS tStart;
XLALGPSSetREAL8 ( &tStart, uvar.t0 );
XLAL_CHECK( xlalErrno == 0, XLAL_EFUNC, "XLALGPSSetREAL8 failed\n" );
MultiLIGOTimeGPSVector *multiTimestamps = NULL;
XLAL_CHECK( (multiTimestamps = XLALMakeMultiTimestamps(tStart, uvar.Tobs, uvar.Tsft, uvar.SFToverlap, detectors->length)) != NULL, XLAL_EFUNC );
LIGOTimeGPS refTime = multiTimestamps->data[0]->data[0];
MultiDetectorStateSeries *multiStateSeries = NULL;
XLAL_CHECK( (multiStateSeries = XLALGetMultiDetectorStates(multiTimestamps, detectors, edat, uvar.SFToverlap)) != NULL, XLAL_EFUNC );
gsl_rng *rng = NULL;
XLAL_CHECK( (rng = gsl_rng_alloc(gsl_rng_mt19937)) != NULL, XLAL_EFUNC );
gsl_rng_set(rng, 0);
FILE *OUTPUT;
XLAL_CHECK( (OUTPUT = fopen(uvar.outfilename,"w")) != NULL, XLAL_EIO, "Output file %s could not be opened\n", uvar.outfilename );
for (INT4 n=0; n<uvar.skylocations; n++) {
SkyPosition skypos;
if (XLALUserVarWasSet(&(uvar.alpha)) && XLALUserVarWasSet(&(uvar.delta)) && n==0) {
skypos.longitude = uvar.alpha;
skypos.latitude = uvar.delta;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
} else {
skypos.longitude = LAL_TWOPI*gsl_rng_uniform(rng);
skypos.latitude = LAL_PI*gsl_rng_uniform(rng) - LAL_PI_2;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
}
REAL8 cosi0, psi0;
if (XLALUserVarWasSet(&(uvar.cosi)) && n==0) cosi0 = uvar.cosi;
else cosi0 = 2.0*gsl_rng_uniform(rng) - 1.0;
if (XLALUserVarWasSet(&(uvar.psi)) && n==0) psi0 = uvar.psi;
else psi0 = LAL_PI*gsl_rng_uniform(rng);
MultiAMCoeffs *multiAMcoefficients = NULL;
XLAL_CHECK( (multiAMcoefficients = XLALComputeMultiAMCoeffs(multiStateSeries, NULL, skypos)) != NULL, XLAL_EFUNC );
MultiSSBtimes *multissb = NULL;
XLAL_CHECK( (multissb = XLALGetMultiSSBtimes(multiStateSeries, skypos, refTime, SSBPREC_RELATIVISTICOPT)) != NULL, XLAL_EFUNC );
REAL8 frequency = 1000.0;
REAL8 frequency0 = frequency + (gsl_rng_uniform(rng)-0.5)/uvar.Tsft;
for (UINT4 ii=0; ii<multiAMcoefficients->data[0]->a->length; ii++) {
REAL4 Fplus0 = multiAMcoefficients->data[0]->a->data[ii]*cos(2.0*psi0) + multiAMcoefficients->data[0]->b->data[ii]*sin(2.0*psi0);
REAL4 Fcross0 = multiAMcoefficients->data[0]->b->data[ii]*cos(2.0*psi0) - multiAMcoefficients->data[0]->a->data[ii]*sin(2.0*psi0);
REAL4 Fplus1 = multiAMcoefficients->data[1]->a->data[ii]*cos(2.0*psi0) + multiAMcoefficients->data[1]->b->data[ii]*sin(2.0*psi0);
REAL4 Fcross1 = multiAMcoefficients->data[1]->b->data[ii]*cos(2.0*psi0) - multiAMcoefficients->data[1]->a->data[ii]*sin(2.0*psi0);
COMPLEX16 RatioTerm0 = crect(0.5*Fplus1*(1.0+cosi0*cosi0), Fcross1*cosi0)/crect(0.5*Fplus0*(1.0+cosi0*cosi0), Fcross0*cosi0); //real det-sig ratio term
REAL4 detPhaseArg = 0.0, detPhaseMag = 0.0;
BOOLEAN loopbroken = 0;
for (INT4 jj=0; jj<16 && !loopbroken; jj++) {
REAL4 psi = 0.0625*jj*LAL_PI;
Fplus0 = multiAMcoefficients->data[0]->a->data[ii]*cos(2.0*psi) + multiAMcoefficients->data[0]->b->data[ii]*sin(2.0*psi);
Fcross0 = multiAMcoefficients->data[0]->b->data[ii]*cos(2.0*psi) - multiAMcoefficients->data[0]->a->data[ii]*sin(2.0*psi);
Fplus1 = multiAMcoefficients->data[1]->a->data[ii]*cos(2.0*psi) + multiAMcoefficients->data[1]->b->data[ii]*sin(2.0*psi);
Fcross1 = multiAMcoefficients->data[1]->b->data[ii]*cos(2.0*psi) - multiAMcoefficients->data[1]->a->data[ii]*sin(2.0*psi);
for (INT4 kk=0; kk<21 && !loopbroken; kk++) {
REAL4 cosi = 1.0 - 2.0*0.05*kk;
if (!uvar.unrestrictedCosi) {
if (cosi0<0.0) cosi = -0.05*kk;
else cosi = 0.05*kk;
}
COMPLEX16 complexnumerator = crect(0.5*Fplus1*(1.0+cosi*cosi), Fcross1*cosi);
COMPLEX16 complexdenominator = crect(0.5*Fplus0*(1.0+cosi*cosi) , Fcross0*cosi);
if (cabs(complexdenominator)>1.0e-6) {
COMPLEX16 complexval = complexnumerator/complexdenominator;
detPhaseMag += fmin(cabs(complexval), 10.0);
detPhaseArg += gsl_sf_angle_restrict_pos(carg(complexval));
} else {
loopbroken = 1;
detPhaseMag = 0.0;
detPhaseArg = 0.0;
}
}
}
detPhaseMag /= 336.0;
detPhaseArg /= 336.0;
COMPLEX16 RatioTerm = cpolar(detPhaseMag, detPhaseArg);
//Bin of interest
REAL8 signalFrequencyBin = round(multissb->data[0]->Tdot->data[ii]*frequency0*uvar.Tsft) - frequency*uvar.Tsft; //estimated nearest freq in ref IFO
REAL8 timediff0 = multissb->data[0]->DeltaT->data[ii] - 0.5*uvar.Tsft*multissb->data[0]->Tdot->data[ii];
REAL8 timediff1 = multissb->data[1]->DeltaT->data[ii] - 0.5*uvar.Tsft*multissb->data[1]->Tdot->data[ii];
REAL8 tau = timediff1 - timediff0;
REAL8 freqshift0 = -LAL_TWOPI*tau*frequency0; //real freq shift
REAL8 freqshift = -LAL_TWOPI*tau*(round(multissb->data[0]->Tdot->data[ii]*frequency0*uvar.Tsft)/uvar.Tsft); //estimated freq shift
COMPLEX16 phaseshift0 = cpolar(1.0, freqshift0);
COMPLEX16 phaseshift = cpolar(1.0, freqshift);
REAL8 delta0_0 = (multissb->data[0]->Tdot->data[ii]*frequency0-frequency)*uvar.Tsft - signalFrequencyBin;
REAL8 delta1_0 = (multissb->data[1]->Tdot->data[ii]*frequency0-frequency)*uvar.Tsft - signalFrequencyBin;
REAL8 realSigBinDiff = round(delta0_0) - round(delta1_0);
delta1_0 += realSigBinDiff;
REAL8 delta0 = round(multissb->data[0]->Tdot->data[ii]*frequency0*uvar.Tsft)*(multissb->data[0]->Tdot->data[ii] - 1.0);
REAL8 delta1 = round(multissb->data[0]->Tdot->data[ii]*frequency0*uvar.Tsft)*(multissb->data[1]->Tdot->data[ii] - 1.0);
REAL8 estSigBinDiff = round(delta0) - round(delta1);
delta1 += estSigBinDiff;
COMPLEX16 dirichlet0;
if (!uvar.rectWindow) {
if (fabsf((REAL4)delta1_0)<(REAL4)1.0e-6) {
if (fabsf((REAL4)delta0_0)<(REAL4)1.0e-6) dirichlet0 = crect(1.0, 0.0);
else if (fabsf((REAL4)(delta0_0*delta0_0-1.0))<(REAL4)1.0e-6) dirichlet0 = crect(-2.0, 0.0);
else if (fabsf((REAL4)(delta0_0-roundf(delta0_0)))<(REAL4)1.0e-6) {
dirichlet0 = crect(0.0, 0.0);
continue;
}
else dirichlet0 = -LAL_PI*crectf(cos(LAL_PI*delta0_0), -sin(LAL_PI*delta0_0))*delta0_0*(delta0_0*delta0_0 - 1.0)/sin(LAL_PI*delta0_0);
}
else if (fabsf((REAL4)(delta1_0*delta1_0-1.0))<(REAL4)1.0e-6) {
if (fabsf((REAL4)delta0_0)<(REAL4)1.0e-6) dirichlet0 = crect(-0.5, 0.0);
else if (fabsf((REAL4)(delta0_0*delta0_0-1.0))<(REAL4)1.0e-6) dirichlet0 = crect(1.0, 0.0);
else if (fabsf((REAL4)(delta0_0-roundf(delta0_0)))<(REAL4)1.0e-6) {
dirichlet0 = crect(0.0, 0.0);
continue;
}
else dirichlet0 = -LAL_PI_2*crectf(-cos(LAL_PI*delta0_0), sin(LAL_PI*delta0_0))*delta0_0*(delta0_0*delta0_0 - 1.0)/sin(LAL_PI*delta0_0);
}
else if (fabsf((REAL4)delta0_0)<(REAL4)1.0e-6) dirichlet0 = -LAL_1_PI*crectf(cos(LAL_PI*delta1_0), sin(LAL_PI*delta1_0))*sin(LAL_PI*delta1_0)/(delta1_0*(delta1_0*delta1_0-1.0));
else if (fabsf((REAL4)(delta0_0*delta0_0-1.0))<(REAL4)1.0e-6) dirichlet0 = LAL_2_PI*crectf(cos(LAL_PI*delta1_0), sin(LAL_PI*delta1_0))*sin(LAL_PI*delta1_0)/(delta1_0*(delta1_0*delta1_0-1.0));
else if (fabsf((REAL4)(delta0_0-roundf(delta0_0)))<(REAL4)1.0e-6) {
dirichlet0 = crect(0.0, 0.0);
continue;
}
else dirichlet0 = sin(LAL_PI*delta1_0)/sin(LAL_PI*delta0_0)*(delta0_0*(delta0_0*delta0_0-1.0))/(delta1_0*(delta1_0*delta1_0-1.0))*cpolarf(1.0,LAL_PI*(delta1_0-delta0_0));
} else {
if (fabsf((REAL4)delta1_0)<(REAL4)1.0e-6) {
if (fabsf((REAL4)delta0_0)<(REAL4)1.0e-6) dirichlet0 = crect(1.0, 0.0);
else if (fabsf((REAL4)(delta0_0-roundf(delta0_0)))<(REAL4)1.0e-6) {
dirichlet0 = crect(0.0, 0.0);
continue;
}
else dirichlet0 = conj(1.0/((cpolar(1.0,LAL_TWOPI*delta0_0)-1.0)/crect(0.0,LAL_TWOPI*delta0_0)));
}
else if (fabsf((REAL4)delta0_0)<(REAL4)1.0e-6) dirichlet0 = conj((cpolar(1.0,LAL_TWOPI*delta1_0)-1.0)/crect(0.0,LAL_TWOPI*delta1_0));
else if (fabsf((REAL4)(delta0_0-roundf(delta0_0)))<(REAL4)1.0e-6) {
dirichlet0 = crect(0.0, 0.0);
continue;
}
else dirichlet0 = conj(((cpolar(1.0,LAL_TWOPI*delta1_0)-1.0)/crect(0.0,LAL_TWOPI*delta1_0))/((cpolar(1.0,LAL_TWOPI*delta0_0)-1.0)/crect(0.0,LAL_TWOPI*delta0_0)));
}
COMPLEX16 dirichlet;
if (!uvar.rectWindow) {
if (fabsf((REAL4)delta1)<(REAL4)1.0e-6) {
if (fabsf((REAL4)delta0)<(REAL4)1.0e-6) dirichlet = crect(1.0, 0.0);
else if (fabsf((REAL4)(delta0*delta0-1.0))<(REAL4)1.0e-6) dirichlet = crect(-2.0, 0.0);
else if (fabsf((REAL4)(delta0-roundf(delta0)))<(REAL4)1.0e-6) dirichlet = crect(0.0, 0.0);
else dirichlet = -LAL_PI*crectf(cos(LAL_PI*delta0), -sin(LAL_PI*delta0))*delta0*(delta0*delta0 - 1.0)/sin(LAL_PI*delta0);
}
else if (fabsf((REAL4)(delta1*delta1-1.0))<(REAL4)1.0e-6) {
if (fabsf((REAL4)delta0)<(REAL4)1.0e-6) dirichlet = crect(-0.5, 0.0);
else if (fabsf((REAL4)(delta0*delta0-1.0))<(REAL4)1.0e-6) dirichlet = crect(1.0, 0.0);
else if (fabsf((REAL4)(delta0-roundf(delta0)))<(REAL4)1.0e-6) dirichlet = crect(0.0, 0.0);
else dirichlet = -LAL_PI_2*crectf(-cos(LAL_PI*delta0), sin(LAL_PI*delta0))*delta0*(delta0*delta0 - 1.0)/sin(LAL_PI*delta0);
}
else if (fabsf((REAL4)delta0)<(REAL4)1.0e-6) dirichlet = -LAL_1_PI*crectf(cos(LAL_PI*delta1), sin(LAL_PI*delta1))*sin(LAL_PI*delta1)/(delta1*(delta1*delta1-1.0));
else if (fabsf((REAL4)(delta0*delta0-1.0))<(REAL4)1.0e-6) dirichlet = LAL_2_PI*crectf(cos(LAL_PI*delta1), sin(LAL_PI*delta1))*sin(LAL_PI*delta1)/(delta1*(delta1*delta1-1.0));
else if (fabsf((REAL4)(delta0-roundf(delta0)))<(REAL4)1.0e-6) dirichlet = crect(0.0, 0.0);
else dirichlet = sin(LAL_PI*delta1)/sin(LAL_PI*delta0)*(delta0*(delta0*delta0-1.0))/(delta1*(delta1*delta1-1.0))*cpolarf(1.0,LAL_PI*(delta1-delta0));
} else {
if (fabsf((REAL4)delta1)<(REAL4)1.0e-6) {
if (fabsf((REAL4)delta0)<(REAL4)1.0e-6) dirichlet = crect(1.0, 0.0);
else if (fabsf((REAL4)(delta0-roundf(delta0)))<(REAL4)1.0e-6) dirichlet = crect(0.0, 0.0);
else dirichlet = conj(1.0/((cpolar(1.0,LAL_TWOPI*delta0)-1.0)/crect(0.0,LAL_TWOPI*delta0)));
}
else if (fabsf((REAL4)delta0)<(REAL4)1.0e-6) dirichlet = conj((cpolar(1.0,LAL_TWOPI*delta1)-1.0)/crect(0.0,LAL_TWOPI*delta1));
else if (fabsf((REAL4)(delta0-roundf(delta0)))<(REAL4)1.0e-6) dirichlet = crect(0.0, 0.0);
else dirichlet = conj(((cpolar(1.0,LAL_TWOPI*delta1)-1.0)/crect(0.0,LAL_TWOPI*delta1))/((cpolar(1.0,LAL_TWOPI*delta0)-1.0)/crect(0.0,LAL_TWOPI*delta0)));
}
dirichlet = cpolar(1.0, carg(dirichlet));
if (fabs(floor(delta0)-floor(delta1))>=1.0) dirichlet *= -1.0;
COMPLEX16 realRatio = RatioTerm0*phaseshift0*conj(dirichlet0);
COMPLEX16 estRatio = RatioTerm*phaseshift*conj(dirichlet);
fprintf(OUTPUT, "%g %g %g %g\n", cabs(realRatio), gsl_sf_angle_restrict_pos(carg(realRatio)), cabs(estRatio), gsl_sf_angle_restrict_pos(carg(estRatio)));
}
XLALDestroyMultiAMCoeffs(multiAMcoefficients);
XLALDestroyMultiSSBtimes(multissb);
}
fclose(OUTPUT);
gsl_rng_free(rng);
XLALDestroyMultiDetectorStateSeries(multiStateSeries);
XLALDestroyMultiTimestamps(multiTimestamps);
XLALDestroyEphemerisData(edat);
XLALFree(detectors);
XLALDestroyUserVars();
}
crect Win::ClientRect()
{
RECT rect;
::GetClientRect(handle,&rect);
return crect(rect.left, rect.top, rect.right, rect.bottom);
}
/**
* \author Sintes, A. M.
*
* \brief Gets data cleaned from line harmonic interference given a time domain reference signal.
*
* ### Description ###
*
* This routine cleans data in the time domain from line harmonic interference
* (from the first harmonic up to the Nyquist frequency). The inputs are:
*
* <tt>*in1</tt> the time domain data of type \c REAL4TVectorCLR,
* containing also the interference fundamental frequency \f$f_0\f$ and the
* sampling spacing. This information is needed in order to obtain
* the total number of harmonics contained in the data.
* <dl>
* <dt><tt>in1->length</tt></dt><dd> The number of elements in <tt>in1->data</tt> \f$=n\f$.</dd>
* <dt><tt>in1->data</tt></dt><dd> The (real) time domain data, \f$x(t)\f$.</dd>
* <dt><tt>in1->deltaT</tt></dt><dd> The sample spacing in seconds.</dd>
* <dt><tt>in1->fLine</tt></dt><dd> The interference fundamental frequency \f$f_0\f$
* (in Hz), e.g., 60 Hz.</dd>
* </dl>
*
* <tt>*in2</tt> the time domain reference signal (a complex vector).
* <dl>
* <dt><tt>in2->length</tt></dt><dd> The number of elements in
* <tt>in2->data</tt> \f$=n\f$.</dd>
* <dt><tt>in2->data</tt></dt><dd> The \f$M(t)\f$ complex data.</dd>
* </dl>
*
* The output <tt>*out</tt> is a real vector containing the clean data.
* <dl>
* <dt><tt>out->length</tt></dt><dd> The number of elements in
* <tt>out->data</tt> \f$=n\f$.</dd>
* <dt><tt>out->data</tt></dt><dd> The clean (real) time domain data.</dd>
* </dl>
*
* ### Algorithm ###
*
* It takes the reference signal \f$M(t)\f$ and, for all possible harmonics
* \f$j\f$
* (\f$j=1,\ldots,\f$<tt>floor(1.0/fabs( 2.02* in1->deltaT * in1->fLine))</tt> ),
* from the fundamental frequency up to the Nyquist frequency,
* constructs \f$M(t)^j\f$, performs a least-squares fit, i.e.,
* minimizes the power \f$\vert x(t) -\rho_j M(t)^j\vert^2\f$ with
* respect to \f$\rho_j\f$, and subtracts \f$\rho_j M(t)^j\f$ from the
* original data, \f$x(t)\f$.
*/
void LALCleanAll (LALStatus *status,/**< LAL status pointer */
REAL4Vector *out, /**< clean data */
COMPLEX8Vector *in2, /**< M(t), ref. interference */
REAL4TVectorCLR *in1) /**< x(t), data + information */
{
INT4 n;
INT4 i,j;
INT4 maxH;
REAL4 *x;
REAL4 *xc;
COMPLEX8 *m;
COMPLEX16 rho,rhon;
REAL8 rhod;
REAL8 mr,mi;
REAL8 amj,phj;
COMPLEX16Vector *mj = NULL;
REAL8Vector *ampM2 = NULL;
REAL8Vector *phaM = NULL;
/* --------------------------------------------- */
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* Make sure the arguments are not NULL: */
ASSERT (out, status, CLRH_ENULL, CLRH_MSGENULL);
ASSERT (in1, status, CLRH_ENULL, CLRH_MSGENULL);
ASSERT (in2, status, CLRH_ENULL, CLRH_MSGENULL);
/* Make sure the data pointers are not NULL: */
ASSERT (out->data, status, CLRH_ENULL, CLRH_MSGENULL);
ASSERT (in1->data, status, CLRH_ENULL, CLRH_MSGENULL);
ASSERT (in2->data, status, CLRH_ENULL, CLRH_MSGENULL);
/* Make sure that the size is correct: */
ASSERT (out->length > 0, status, CLRH_ESIZE, CLRH_MSGESIZE);
/* Make sure that the lengths are correct (size mismatch): */
ASSERT (in1->length == out->length, status, CLRH_ESZMM, CLRH_MSGESZMM);
ASSERT (in2->length == out->length, status, CLRH_ESZMM, CLRH_MSGESZMM);
/* Make sure the arguments are not pointing to the same memory location */
/* ASSERT (out != in2, status, CLRH_ESAME, CLRH_MSGESAME); */
/* Make sure F_Nyquist > fLine */
ASSERT (fabs(in1->deltaT * in1->fLine) < 0.495,
status, CLRH_EFREQ, CLRH_MSGEFREQ);
/* margin 0.495 and not 0.5 in order to avoid errors */
/* ------------------------------------------- */
n = out->length;
m = in2->data;
x = in1->data;
xc = out->data;
/* ------------------------------------------- */
/* Removing the fundamental harmonic */
/* ------------------------------------------- */
rhon = 0.0;
rhod = 0.0;
for (i=0; i<n; ++i) {
mr = crealf(m[i]);
mi = cimagf(m[i]);
rhon += crect( x[i]*mr, -x[i]*mi );
rhod += mr*mr + mi*mi;
}
rho = (rhon / ((REAL8) rhod));
for (i=0; i<n; ++i) {
xc[i] = x[i] - 2.0*(creal(rho) * crealf(m[i]) - cimag(rho) * cimagf(m[i]) );
}
/* ------------------------------------------- */
/* Removing the other harmonics */
/* ------------------------------------------- */
maxH= floor(1.0/fabs( 2.02* in1->deltaT * in1->fLine));
if (maxH > 1) /* in case there are more harmonics */
{
/* Create Vectors amplitude and phase m(t) */
TRY(LALDCreateVector(status->statusPtr, &M2, n), status);
TRY(LALDCreateVector(status->statusPtr, &phaM, n), status);
/* reserve space for m^j(t) */
TRY(LALZCreateVector(status->statusPtr, &mj ,n), status);
for (i=0; i<n; ++i) {
/* calculation of amplitude^2 and phase of m(t) */
mr = crealf(m[i]);
mi = cimagf(m[i]);
ampM2->data[i] = mr*mr+ mi*mi;
if( ampM2->data[i] < LAL_REAL4_MIN)
{ phaM->data[i] = 0.0; /* to avoid NaN */ }
else
{ phaM->data[i] = atan2(mi,mr); }
}
for(j=2; j<= maxH; ++j) {
rhon = 0.0;
rhod = 0.0;
for (i=0; i<n; ++i) {
/* calculation of m^j(t) for a fixed t */
amj = pow( ampM2->data[i], 0.5*j);
phj = j * phaM->data[i];
mj->data[i] = crect( amj * cos(phj), amj * sin(phj) );
mr = creal(mj->data[i]);
mi = cimag(mj->data[i]);
rhon += crect( xc[i]*mr, -xc[i]*mi );
rhod += mr*mr + mi*mi;
}
rho = (rhon / ((REAL8) rhod));
for (i=0; i<n; ++i) {
xc[i] += - 2.0*(creal(rho) * creal(mj->data[i]) - cimag(rho) * cimag(mj->data[i]) );
}
} /* closes for all harmonics */
/* Destroy Vectors */
TRY(LALDDestroyVector(status->statusPtr, &M2), status);
TRY(LALDDestroyVector(status->statusPtr, &phaM), status);
TRY(LALZDestroyVector(status->statusPtr, &mj), status);
} /* closes if */
/* ------------------------------------------- */
DETATCHSTATUSPTR (status);
/* normal exit */
RETURN (status);
}
int main(int argc, char *argv[])
{
UserVariables_t XLAL_INIT_DECL(uvar);
XLAL_CHECK ( InitUserVars(&uvar, argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
MultiLALDetector *detectors = NULL;
XLAL_CHECK( (detectors = XLALMalloc(sizeof(MultiLALDetector))) != NULL, XLAL_ENOMEM );
detectors->length = uvar.IFO->length;
for (UINT4 ii=0; ii<detectors->length; ii++) {
if (strcmp("H1", uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_LHO_4K_DETECTOR]; //H1
} else if (strcmp("L1",uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_LLO_4K_DETECTOR]; //L1
} else if (strcmp("V1", uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_VIRGO_DETECTOR]; //V1
} else if (strcmp("H2", uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_LHO_2K_DETECTOR]; //H2
} else if (strcmp("H2r", uvar.IFO->data[ii])==0) {
LALDetector H2 = lalCachedDetectors[LAL_LHO_2K_DETECTOR]; //H2 rotated
H2.frDetector.xArmAzimuthRadians -= 0.25*LAL_PI;
H2.frDetector.yArmAzimuthRadians -= 0.25*LAL_PI;
memset(&(H2.frDetector.name), 0, sizeof(CHAR)*LALNameLength);
snprintf(H2.frDetector.name, LALNameLength, "%s", "LHO_2k_rotatedPiOver4");
XLAL_CHECK( (XLALCreateDetector(&(detectors->sites[ii]), &(H2.frDetector), LALDETECTORTYPE_IFODIFF)) != NULL, XLAL_EFUNC );
} else {
XLAL_ERROR(XLAL_EINVAL, "Not using valid interferometer! Expected 'H1', 'H2', 'H2r' (rotated H2), 'L1', or 'V1' not %s.\n", uvar.IFO->data[ii]);
}
}
EphemerisData *edat = NULL;
XLAL_CHECK( (edat = XLALInitBarycenter(uvar.ephemEarth, uvar.ephemSun)) != NULL, XLAL_EFUNC );
LIGOTimeGPS tStart;
XLALGPSSetREAL8 ( &tStart, uvar.t0 );
XLAL_CHECK( xlalErrno == 0, XLAL_EFUNC, "XLALGPSSetREAL8 failed\n" );
MultiLIGOTimeGPSVector *multiTimestamps = NULL;
XLAL_CHECK( (multiTimestamps = XLALMakeMultiTimestamps(tStart, uvar.Tobs, uvar.Tsft, uvar.SFToverlap, detectors->length)) != NULL, XLAL_EFUNC );
LIGOTimeGPS refTime = multiTimestamps->data[0]->data[0];
MultiDetectorStateSeries *multiStateSeries = NULL;
XLAL_CHECK( (multiStateSeries = XLALGetMultiDetectorStates(multiTimestamps, detectors, edat, uvar.SFToverlap)) != NULL, XLAL_EFUNC );
gsl_rng *rng = NULL;
XLAL_CHECK( (rng = gsl_rng_alloc(gsl_rng_mt19937)) != NULL, XLAL_EFUNC );
gsl_rng_set(rng, 0);
FILE *OUTPUT;
XLAL_CHECK( (OUTPUT = fopen(uvar.outfilename,"w")) != NULL, XLAL_EIO, "Output file %s could not be opened\n", uvar.outfilename );
for (INT4 n=0; n<uvar.skylocations; n++) {
SkyPosition skypos;
if (XLALUserVarWasSet(&(uvar.alpha)) && XLALUserVarWasSet(&(uvar.delta)) && n==0) {
skypos.longitude = uvar.alpha;
skypos.latitude = uvar.delta;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
} else {
skypos.longitude = LAL_TWOPI*gsl_rng_uniform(rng);
skypos.latitude = LAL_PI*gsl_rng_uniform(rng) - LAL_PI_2;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
}
REAL8 cosi0, psi0;
if (XLALUserVarWasSet(&(uvar.cosi)) && n==0) cosi0 = uvar.cosi;
else cosi0 = 2.0*gsl_rng_uniform(rng) - 1.0;
if (XLALUserVarWasSet(&(uvar.psi)) && n==0) psi0 = uvar.psi;
else psi0 = LAL_PI*gsl_rng_uniform(rng);
MultiAMCoeffs *multiAMcoefficients = NULL;
XLAL_CHECK( (multiAMcoefficients = XLALComputeMultiAMCoeffs(multiStateSeries, NULL, skypos)) != NULL, XLAL_EFUNC );
MultiSSBtimes *multissb = NULL;
XLAL_CHECK( (multissb = XLALGetMultiSSBtimes(multiStateSeries, skypos, refTime, SSBPREC_RELATIVISTICOPT)) != NULL, XLAL_EFUNC );
REAL8 frequency0 = 1000.0 + (gsl_rng_uniform(rng)-0.5)/uvar.Tsft;
REAL8 frequency = 1000.0;
for (UINT4 ii=0; ii<multiAMcoefficients->data[0]->a->length; ii++) {
REAL4 Fplus0 = multiAMcoefficients->data[0]->a->data[ii]*cos(2.0*psi0) + multiAMcoefficients->data[0]->b->data[ii]*sin(2.0*psi0);
REAL4 Fcross0 = multiAMcoefficients->data[0]->b->data[ii]*cos(2.0*psi0) - multiAMcoefficients->data[0]->a->data[ii]*sin(2.0*psi0);
REAL4 Fplus1 = multiAMcoefficients->data[1]->a->data[ii]*cos(2.0*psi0) + multiAMcoefficients->data[1]->b->data[ii]*sin(2.0*psi0);
REAL4 Fcross1 = multiAMcoefficients->data[1]->b->data[ii]*cos(2.0*psi0) - multiAMcoefficients->data[1]->a->data[ii]*sin(2.0*psi0);
COMPLEX16 RatioTerm0 = crect(0.5*Fplus1*(1.0+cosi0*cosi0), Fcross1*cosi0)/crect(0.5*Fplus0*(1.0+cosi0*cosi0), Fcross0*cosi0);
REAL4 detPhaseArg = 0.0, detPhaseMag = 0.0;
BOOLEAN loopbroken = 0;
for (INT4 jj=0; jj<50 && !loopbroken; jj++) {
REAL4 psi = 0.02*jj*LAL_PI;
Fplus0 = multiAMcoefficients->data[0]->a->data[ii]*cos(2.0*psi) + multiAMcoefficients->data[0]->b->data[ii]*sin(2.0*psi);
Fcross0 = multiAMcoefficients->data[0]->b->data[ii]*cos(2.0*psi) - multiAMcoefficients->data[0]->a->data[ii]*sin(2.0*psi);
Fplus1 = multiAMcoefficients->data[1]->a->data[ii]*cos(2.0*psi) + multiAMcoefficients->data[1]->b->data[ii]*sin(2.0*psi);
Fcross1 = multiAMcoefficients->data[1]->b->data[ii]*cos(2.0*psi) - multiAMcoefficients->data[1]->a->data[ii]*sin(2.0*psi);
for (INT4 kk=0; kk<51 && !loopbroken; kk++) {
//REAL4 cosi = 1.0 - 2.0*0.02*kk;
REAL4 cosi;
if (cosi0<0.0) cosi = -0.02*kk;
else cosi = 0.02*kk;
COMPLEX16 complexnumerator = crect(0.5*Fplus1*(1.0+cosi*cosi), Fcross1*cosi);
COMPLEX16 complexdenominator = crect(0.5*Fplus0*(1.0+cosi*cosi) , Fcross0*cosi);
if (cabs(complexdenominator)>1.0e-7) {
COMPLEX16 complexval = complexnumerator/complexdenominator;
detPhaseMag += fmin(cabs(complexval), 10.0);
detPhaseArg += gsl_sf_angle_restrict_pos(carg(complexval));
} else {
loopbroken = 1;
detPhaseMag = 0.0;
detPhaseArg = 0.0;
}
}
}
detPhaseMag /= 2550.0;
detPhaseArg /= 2550.0;
REAL8 timediff0 = multissb->data[0]->DeltaT->data[ii] - 0.5*uvar.Tsft*multissb->data[0]->Tdot->data[ii];
REAL8 timediff1 = multissb->data[1]->DeltaT->data[ii] - 0.5*uvar.Tsft*multissb->data[1]->Tdot->data[ii];
REAL8 tau = timediff1 - timediff0;
REAL8 freqshift0 = -LAL_TWOPI*tau*frequency0;
REAL8 freqshift = -LAL_TWOPI*tau*frequency;
REAL8 nearestFrequency = round(multissb->data[0]->Tdot->data[ii]*frequency*uvar.Tsft)/uvar.Tsft;
COMPLEX16 dirichlet0 = conj(DirichletKernelLargeNHann((multissb->data[1]->Tdot->data[ii]*frequency0-nearestFrequency)*uvar.Tsft)/DirichletKernelLargeNHann((multissb->data[0]->Tdot->data[ii]*frequency0-nearestFrequency)*uvar.Tsft));
COMPLEX16 dirichlet = conj(DirichletKernelLargeNHann((multissb->data[1]->Tdot->data[ii]*frequency-nearestFrequency)*uvar.Tsft)/DirichletKernelLargeNHann((multissb->data[0]->Tdot->data[ii]*frequency-nearestFrequency)*uvar.Tsft));
COMPLEX16 signal0 = 0.5*crect(0.5*Fplus0*(1.0+cosi0*cosi0), Fcross0*cosi0)*cpolar(1.0, LAL_TWOPI*frequency0*0.5*uvar.Tsft+LAL_TWOPI*frequency0*(multissb->data[0]->DeltaT->data[ii]+multissb->data[0]->Tdot->data[ii]*0.5*uvar.Tsft))*uvar.Tsft*DirichletKernelLargeNHann((multissb->data[0]->Tdot->data[ii]*frequency0-nearestFrequency)*uvar.Tsft);
COMPLEX16 signal1 = 0.5*crect(0.5*Fplus1*(1.0+cosi0*cosi0), Fcross1*cosi0)*cpolar(1.0, LAL_TWOPI*frequency0*0.5*uvar.Tsft+LAL_TWOPI*frequency0*(multissb->data[1]->DeltaT->data[ii]+multissb->data[1]->Tdot->data[ii]*0.5*uvar.Tsft))*uvar.Tsft*DirichletKernelLargeNHann((multissb->data[1]->Tdot->data[ii]*frequency0-nearestFrequency)*uvar.Tsft);
fprintf(OUTPUT, "%g %g %g %g %g %g %g %g %g %g %g %g %g %g\n", cabs(signal0), gsl_sf_angle_restrict_pos(carg(signal0)), cabs(signal1), gsl_sf_angle_restrict_pos(carg(signal1)), cabs(RatioTerm0), gsl_sf_angle_restrict_pos(carg(RatioTerm0)), detPhaseMag, detPhaseArg, freqshift0, freqshift, cabs(dirichlet0), gsl_sf_angle_restrict_pos(carg(dirichlet0)), cabs(dirichlet), gsl_sf_angle_restrict_pos(carg(dirichlet)));
//fprintf(OUTPUT, "%g %g %g %g\n", cabs(signal0), gsl_sf_angle_restrict_pos(carg(signal0)), cabs(signal1), gsl_sf_angle_restrict_pos(carg(signal1)));
}
XLALDestroyMultiAMCoeffs(multiAMcoefficients);
XLALDestroyMultiSSBtimes(multissb);
}
fclose(OUTPUT);
gsl_rng_free(rng);
XLALDestroyMultiDetectorStateSeries(multiStateSeries);
XLALDestroyMultiTimestamps(multiTimestamps);
XLALDestroyEphemerisData(edat);
XLALFree(detectors);
XLALDestroyUserVars();
}
void
LALCoarseFitToPulsar ( LALStatus *status,
CoarseFitOutput *output,
CoarseFitInput *input,
CoarseFitParams *params )
{
/******* DECLARE VARIABLES ************/
UINT4 n,i; /* integer indices */
REAL8 psi;
REAL8 h0/*,h*/;
REAL8 cosIota;
REAL8 phase;
REAL8 chiSquare;
LALDetector detector;
LALSource pulsar;
LALDetAndSource detAndSource;
LALDetAMResponse computedResponse;
REAL4Vector *Fp, *Fc; /* pointers to amplitude responses of the detector */
REAL8Vector *var;
REAL8 cos2phase,sin2phase;
COMPLEX16 Xp, Xc;
REAL8 Y, cosIota2;
COMPLEX16 A,B;
REAL8 sumAA, sumBB, sumAB;
REAL8 h0BestFit=0,phaseBestFit=0, psiBestFit=0, cosIotaBestFit=0;
REAL8 minChiSquare;
COMPLEX16 eh0;
REAL8 oldMinEh0, oldMaxEh0, weh0;
UINT4 iH0, iCosIota, iPhase, iPsi, arg;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/******* CHECK VALIDITY OF ARGUMENTS ************/
ASSERT(output != (CoarseFitOutput *)NULL, status,
FITTOPULSARH_ENULLOUTPUT, FITTOPULSARH_MSGENULLOUTPUT);
ASSERT(params != (CoarseFitParams *)NULL, status,
FITTOPULSARH_ENULLPARAMS, FITTOPULSARH_MSGENULLPARAMS);
ASSERT(input != (CoarseFitInput *)NULL, status,
FITTOPULSARH_ENULLINPUT, FITTOPULSARH_MSGENULLINPUT);
ASSERT(input->B->length == input->var->length, status,
FITTOPULSARH_EVECSIZE , FITTOPULSARH_MSGEVECSIZE );
/******* EXTRACT INPUTS AND PARAMETERS ************/
n = input->B->length;
for (i = 0; i < n; i++)
ASSERT(creal(input->var->data[i]) > 0.0 && cimag(input->var->data[i]) > 0.0, status,
FITTOPULSARH_EVAR, FITTOPULSARH_MSGEVAR);
detector = params->detector;
detAndSource.pDetector = &detector;
pulsar = params->pulsarSrc;
/******* ALLOCATE MEMORY TO VECTORS **************/
Fp = NULL;
LALSCreateVector(status->statusPtr, &Fp, n);
Fp->length = n;
Fc = NULL;
LALSCreateVector(status->statusPtr, &Fc, n);
Fc->length = n;
var = NULL;
LALDCreateVector(status->statusPtr, &var, n);
var->length = n;
/******* INITIALIZE VARIABLES *******************/
minChiSquare = INICHISQU;
oldMaxEh0 = INIMAXEH;
oldMinEh0 = INIMINEH;
for (i=0;i<n;i++)
{
var->data[i] = creal(input->var->data[i]) + cimag(input->var->data[i]);
}
/******* DO ANALYSIS ************/
for (iPsi = 0; iPsi < params->meshPsi[2]; iPsi++)
{
psi = params->meshPsi[0] + iPsi*params->meshPsi[1];
pulsar.orientation = psi;
detAndSource.pSource = &pulsar;
/* create vectors containing amplitude response of detector for specified times */
for (i=0;i<n;i++)
{
LALComputeDetAMResponse(status->statusPtr, &computedResponse,&detAndSource, &input->t[i]);
Fp->data[i] = (REAL8)computedResponse.plus;
Fc->data[i] = (REAL8)computedResponse.cross;
}
for (iPhase = 0; iPhase < params->meshPhase[2]; iPhase++)
{
phase = params->meshPhase[0] + iPhase*params->meshPhase[1];
cos2phase = cos(2.0*phase);
sin2phase = sin(2.0*phase);
for (iCosIota = 0; iCosIota < params->meshCosIota[2]; iCosIota++)
{
cosIota = params->meshCosIota[0] + iCosIota*params->meshCosIota[1];
cosIota2 = 1.0 + cosIota*cosIota;
Xp = crect( cosIota2 * cos2phase, cosIota2 * sin2phase );
Y = 2.0*cosIota;
Xc = crect( Y*sin2phase, -Y*cos2phase );
sumAB = 0.0;
sumAA = 0.0;
sumBB = 0.0;
eh0 = 0.0;
for (i = 0; i < n; i++)
{
B = input->B->data[i];
A = crect( Fp->data[i]*creal(Xp) + Fc->data[i]*creal(Xc), Fp->data[i]*cimag(Xp) + Fc->data[i]*cimag(Xc) );
sumBB += (creal(B)*creal(B) + cimag(B)*cimag(B)) / var->data[i];
sumAA += (creal(A)*creal(A) + cimag(A)*cimag(A)) / var->data[i];
sumAB += (creal(B)*creal(A) + cimag(B)*cimag(A)) / var->data[i];
/**** calculate error on h0 **********/
eh0 += crect( (Fp->data[i]*cosIota2*cos2phase + 2.0*Fc->data[i]*cosIota*sin2phase) * (Fp->data[i]*cosIota2*cos2phase + 2.0*Fc->data[i]*cosIota*sin2phase) / creal(input->var->data[i]), (Fp->data[i]*cosIota2*sin2phase - 2.0*Fc->data[i]*cosIota*cos2phase) * (Fp->data[i]*cosIota2*sin2phase - 2.0*Fc->data[i]*cosIota*cos2phase) / cimag(input->var->data[i]) );
}
for (iH0 = 0; iH0 < params->meshH0[2]; iH0++)
{
h0 = params->meshH0[0] + iH0*params->meshH0[1];
chiSquare = sumBB - 2.0*h0*sumAB + h0*h0*sumAA;
if (chiSquare<minChiSquare)
{
minChiSquare = chiSquare;
h0BestFit = h0;
cosIotaBestFit = cosIota;
psiBestFit = psi;
phaseBestFit = phase;
output->eh0[0] = 1.0 /sqrt(sqrt(creal(eh0)*creal(eh0) + cimag(eh0)*cimag(eh0)));
}
weh0 = 1.0 /sqrt(sqrt(creal(eh0)*creal(eh0) + cimag(eh0)*cimag(eh0)));
if (weh0>oldMaxEh0)
{
output->eh0[2] = weh0;
oldMaxEh0 = weh0;
}
if (weh0<oldMinEh0)
{
output->eh0[1] = weh0;
oldMinEh0 = weh0;
}
arg = iH0 + params->meshH0[2]*(iCosIota + params->meshCosIota[2]*(iPhase + params->meshPhase[2]*iPsi));
output->mChiSquare->data[arg] = chiSquare;
}
}
}
}
/******* CONSTRUCT OUTPUT ************/
output->h0 = h0BestFit;
output->cosIota = cosIotaBestFit;
output->phase = phaseBestFit;
output->psi = psiBestFit;
output->chiSquare = minChiSquare;
ASSERT(minChiSquare < INICHISQU, status,
FITTOPULSARH_EMAXCHI , FITTOPULSARH_MSGEMAXCHI);
LALSDestroyVector(status->statusPtr, &Fp);
LALSDestroyVector(status->statusPtr, &Fc);
LALDDestroyVector(status->statusPtr, &var);
DETATCHSTATUSPTR(status);
RETURN(status);
}
/* Revamped version of LALDemod() (based on TestLALDemod() in CFS).
* Compute JKS's Fa and Fb, which are ingredients for calculating the F-statistic.
*/
static int
LocalXLALComputeFaFb ( Fcomponents *FaFb,
const SFTVector *sfts,
const PulsarSpins fkdot,
const SSBtimes *tSSB,
const AMCoeffs *amcoe,
const ComputeFParams *params) /* addition computational params */
{
UINT4 alpha; /* loop index over SFTs */
UINT4 spdnOrder; /* maximal spindown-orders */
UINT4 numSFTs; /* number of SFTs (M in the Notes) */
COMPLEX16 Fa, Fb;
REAL8 Tsft; /* length of SFTs in seconds */
INT4 freqIndex0; /* index of first frequency-bin in SFTs */
INT4 freqIndex1; /* index of last frequency-bin in SFTs */
REAL4 *a_al, *b_al; /* pointer to alpha-arrays over a and b */
REAL8 *DeltaT_al, *Tdot_al; /* pointer to alpha-arrays of SSB-timings */
SFTtype *SFT_al; /* SFT alpha */
REAL8 norm = OOTWOPI;
XLAL_CHECK ( params->Dterms == DTERMS, XLAL_EDOM );
#ifndef LAL_NDEBUG
/* ----- check validity of input */
if ( !FaFb ) {
XLALPrintError ("\nOutput-pointer is NULL !\n\n");
XLAL_ERROR ( XLAL_EINVAL);
}
if ( !sfts || !sfts->data ) {
XLALPrintError ("\nInput SFTs are NULL!\n\n");
XLAL_ERROR ( XLAL_EINVAL);
}
if ( !tSSB || !tSSB->DeltaT || !tSSB->Tdot || !amcoe || !amcoe->a || !amcoe->b || !params)
{
XLALPrintError ("\nIllegal NULL in input !\n\n");
XLAL_ERROR ( XLAL_EINVAL);
}
#endif
/* ----- prepare convenience variables */
numSFTs = sfts->length;
Tsft = 1.0 / sfts->data[0].deltaF;
{
REAL8 dFreq = sfts->data[0].deltaF;
freqIndex0 = lround ( sfts->data[0].f0 / dFreq ); /* lowest freqency-index */
freqIndex1 = freqIndex0 + sfts->data[0].data->length;
}
static int firstcall = 1; /* for sin/cos lookup table initialization */
if (firstcall)
{
/* init sin/cos lookup tables */
local_sin_cos_2PI_LUT_init();
/* make sure Dterms is what we expect */
XLAL_CHECK (DTERMS == params->Dterms, XLAL_EINVAL, "LocalXLALComputeFaFb() has been compiled with fixed DTERMS (%d) != params->Dtems (%d)\n", DTERMS, params->Dterms );
firstcall = 0;
}
/* find highest non-zero spindown-entry */
for ( spdnOrder = PULSAR_MAX_SPINS - 1; spdnOrder > 0 ; spdnOrder -- )
if ( fkdot[spdnOrder] != 0.0 )
break;
Fa = 0.0f;
Fb = 0.0f;
a_al = amcoe->a->data; /* point to beginning of alpha-arrays */
b_al = amcoe->b->data;
DeltaT_al = tSSB->DeltaT->data;
Tdot_al = tSSB->Tdot->data;
SFT_al = sfts->data;
/* Loop over all SFTs */
for ( alpha = 0; alpha < numSFTs; alpha++ )
{
REAL4 a_alpha, b_alpha;
INT4 kstar; /* central frequency-bin k* = round(xhat_alpha) */
INT4 k0, k1;
COMPLEX8 *Xalpha = SFT_al->data->data; /* pointer to current SFT-data */
REAL4 s_alpha, c_alpha; /* sin(2pi kappa_alpha) and (cos(2pi kappa_alpha)-1) */
REAL4 realQ, imagQ; /* Re and Im of Q = e^{-i 2 pi lambda_alpha} */
REAL4 realXP, imagXP; /* re/im of sum_k X_ak * P_ak */
REAL4 realQXP, imagQXP; /* Re/Im of Q_alpha R_alpha */
REAL8 lambda_alpha, kappa_star;
/* ----- calculate lambda_alpha */
{
UINT4 s; /* loop-index over spindown-order */
REAL8 phi_alpha, Dphi_alpha, DT_al;
REAL8 Tas; /* temporary variable to calculate (DeltaT_alpha)^s */
REAL8 TAS_invfact_s;
/* init for s=0 */
phi_alpha = 0.0;
Dphi_alpha = 0.0;
DT_al = (*DeltaT_al);
Tas = 1.0; /* DeltaT_alpha ^ 0 */
TAS_invfact_s=1.0; /* TAS / s! */
for (s=0; s <= spdnOrder; s++) {
REAL8 fsdot = fkdot[s];
Dphi_alpha += fsdot * TAS_invfact_s; /* here: DT^s/s! */
#ifdef EAH_CHECK_FINITE_DPHI
if (!finite(Dphi_alpha)) {
LogPrintf(LOG_CRITICAL, "non-finite Dphi_alpha:%e, alpha:%d, spind#:%d, fkdot:%e, Tas:%e, LAL_FACT_INV[s]:%e, LAL_FACT_INV[s+1]:%e, phi_alpha:%e. DT_al:%e\n",
Dphi_alpha, alpha, s, fkdot[s], Tas, LAL_FACT_INV[s], LAL_FACT_INV[s+1], phi_alpha, DT_al);
XLAL_ERROR("LocalXLALComputeFaFb", XLAL_EDOM);
}
#endif
Tas *= DT_al; /* now: DT^(s+1) */
TAS_invfact_s= Tas * LAL_FACT_INV[s+1];
phi_alpha += fsdot * TAS_invfact_s;
} /* for s <= spdnOrder */
/* Step 3: apply global factors to complete Dphi_alpha */
Dphi_alpha *= Tsft * (*Tdot_al); /* guaranteed > 0 ! */
#ifndef EAH_NO_CHECK_FINITE_DPHI
if (!finite(Dphi_alpha)) {
LogPrintf(LOG_CRITICAL, "non-finite Dphi_alpha:%e, alpha:%d, Tsft:%e, Tkdot_al:%e Tas:%e, DT_al:%e\n",
Dphi_alpha, alpha, Tsft, (*Tdot_al), Tas, DT_al);
XLAL_ERROR( XLAL_EDOM );
}
#endif
lambda_alpha = 0.5 * Dphi_alpha - phi_alpha;
/* FIXME: that might be possible to do faster */
kstar = (INT4) (Dphi_alpha); /* k* = floor(Dphi_alpha*chi) for positive Dphi */
kappa_star = Dphi_alpha - 1.0 * kstar; /* remainder of Dphi_alpha: >= 0 ! */
/* ----- check that required frequency-bins are found in the SFTs ----- */
k0 = kstar - DTERMS + 1;
/*
original:
k1 = k0 + 2 * DTERMS - 1;
inserted k0:
k1 = kstar - DTERMS + 1 + 2 * DTERMS - 1;
shortened:
*/
k1 = kstar + DTERMS;
if ( (k0 < freqIndex0) || (k1 > freqIndex1) )
{
LogPrintf(LOG_CRITICAL,
"Required frequency-bins [%d, %d] not covered by SFT-interval [%d, %d]\n"
"\t\t[Parameters: alpha:%d, Dphi_alpha:%e, Tsft:%e, *Tdot_al:%e]\n",
k0, k1, freqIndex0, freqIndex1,
alpha, Dphi_alpha, Tsft, *Tdot_al);
XLAL_ERROR(XLAL_EDOM);
}
} /* compute kappa_star, lambda_alpha */
/* ---------- calculate the (truncated to DTERMS) sum over k ---------- */
/* ---------- ATTENTION: this the "hot-loop", which will be
* executed many millions of times, so anything in here
* has a HUGE impact on the whole performance of the code.
*
* DON'T touch *anything* in here unless you really know
* what you're doing !!
*------------------------------------------------------------
*/
{
COMPLEX8 *Xalpha_l = Xalpha + k0 - freqIndex0; /* first frequency-bin in sum */
/* if no danger of denominator -> 0 */
#ifdef __GNUC__
/* somehow the branch prediction of gcc-4.1.2 terribly failes
with the current case distinction in the hot-loop,
having a severe impact on runtime of the E@H Linux App.
So let's allow to give gcc a hint which path has a higher probablility */
if (__builtin_expect((kappa_star > LD_SMALL4) && (kappa_star < 1.0 - LD_SMALL4), (0==0)))
#else
if ((kappa_star > LD_SMALL4) && (kappa_star < 1.0 - LD_SMALL4))
#endif
{
/* WARNING: all current optimized loops rely on current implementation of COMPLEX8 and DTERMS == 8 */
#include OPT_DEMOD_SOURCE
} /* if |remainder| > LD_SMALL4 */
else
{ /* otherwise: lim_{rem->0}P_alpha,k = 2pi delta_{k,kstar} */
UINT4 ind0;
/* realQ/imagQ are calculated in the hotloop in the other case; in this case we have to do it too */
SINCOS_TRIM_X (lambda_alpha,lambda_alpha);
SINCOS_2PI_TRIMMED( &imagQ, &realQ, lambda_alpha );
if ( kappa_star <= LD_SMALL4 ) {
ind0 = DTERMS - 1;
} else {
ind0 = DTERMS;
}
realXP = TWOPI_FLOAT * crealf(Xalpha_l[ind0]);
imagXP = TWOPI_FLOAT * cimagf(Xalpha_l[ind0]);
} /* if |remainder| <= LD_SMALL4 */
}
/* real- and imaginary part of e^{-i 2 pi lambda_alpha } */
realQXP = realQ * realXP - imagQ * imagXP;
imagQXP = realQ * imagXP + imagQ * realXP;
/* we're done: ==> combine these into Fa and Fb */
a_alpha = (*a_al);
b_alpha = (*b_al);
Fa += crect( a_alpha * realQXP, a_alpha * imagQXP );
Fb += crect( b_alpha * realQXP, b_alpha * imagQXP );
/* advance pointers over alpha */
a_al ++;
b_al ++;
DeltaT_al ++;
Tdot_al ++;
SFT_al ++;
} /* for alpha < numSFTs */
/* return result */
FaFb->Fa = norm * Fa;
FaFb->Fb = norm * Fb;
return XLAL_SUCCESS;
} // LocalXLALComputeFaFb()
