00001 #include "AIDA_DevDataPointSetFactory.h"
00002 #include "AIDA_DataPointSet.h"
00003 #include "AIDA/IDataPoint.h"
00004 #include "AIDA/IMeasurement.h"
00005 #include "AIDA/IAxis.h"
00006 #include "AIDA/IAnnotation.h"
00007 #include "AIDA/IHistogram1D.h"
00008 #include "AIDA/IHistogram2D.h"
00009 #include "AIDA/IHistogram3D.h"
00010 #include "AIDA/ICloud1D.h"
00011 #include "AIDA/ICloud2D.h"
00012 #include "AIDA/ICloud3D.h"
00013 #include "AIDA/IProfile1D.h"
00014 #include "AIDA/IProfile2D.h"
00015 #include <set>
00016 #include <cmath>
00017
00018
00019 #include <memory>
00020 #include <stdexcept>
00021 #include "AIDA_Dev/IDevAnalysisFactory.h"
00022 #include "AIDA_Dev/IAnnotationFactory.h"
00023
00024 AIDA::IAnnotation*
00025 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::createAnnotation()
00026 {
00027 std::auto_ptr<AIDA::Dev::IDevAnalysisFactory> af(dynamic_cast<AIDA::Dev::IDevAnalysisFactory*>(AIDA_createAnalysisFactory() ));
00028 if ( ! af.get() ) throw std::runtime_error( "Could not create an analysis factory" );
00029 AIDA::Dev::IAnnotationFactory* anf = af->annotationFactory();
00030 if ( ! anf ) throw std::runtime_error( "Could not find an annotation factory" );
00031 return anf->createAnnotation();
00032 }
00033
00034
00035 static const std::string emptyString = "";
00036
00037 AIDA::Dev::IDevDataPointSet*
00038 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::create( const std::string& title,
00039 int dimensionOfPoint )
00040 {
00041 return new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( title, dimensionOfPoint, createAnnotation() );
00042 }
00043
00044
00045 AIDA::Dev::IDevDataPointSet*
00046 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::create( int dimensionOfPoint )
00047 {
00048 return new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( emptyString, dimensionOfPoint, createAnnotation() );
00049 }
00050
00051
00052 AIDA::Dev::IDevDataPointSet*
00053 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::createCopy( const AIDA::IDataPointSet & original )
00054 {
00055 return new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( original, createAnnotation() );
00056 }
00057
00058
00059 bool
00060 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::destroy( AIDA::IDataPointSet * dataPointSet )
00061 {
00062 if ( dataPointSet ) {
00063 delete dataPointSet;
00064 return true;
00065 }
00066 else return false;
00067 }
00068
00069
00070 AIDA::Dev::IDevDataPointSet*
00071 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::create( const AIDA::IHistogram1D & h )
00072 {
00073 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( h.title(), h.dimension() + 1, createAnnotation() );
00074
00075
00076 const AIDA::IAxis& xAxis = h.axis();
00077 for ( int i = 0; i < xAxis.bins(); ++i ) {
00078 p->addPoint();
00079 AIDA::IDataPoint* point = p->point(i);
00080 AIDA::IMeasurement* xMeasurement = point->coordinate( 0 );
00081 xMeasurement->setValue( h.binMean( i ) );
00082 xMeasurement->setErrorPlus( xAxis.binUpperEdge( i ) - xMeasurement->value() );
00083 xMeasurement->setErrorMinus( xMeasurement->value() - xAxis.binLowerEdge( i ) );
00084
00085 AIDA::IMeasurement* yMeasurement = point->coordinate( 1 );
00086 const double height = h.binHeight( i );
00087 const double error = h.binError( i );
00088 yMeasurement->setValue( height );
00089 yMeasurement->setErrorPlus( error );
00090 yMeasurement->setErrorMinus( error );
00091 }
00092
00093
00094 AIDA::IAnnotation& annotation = p->annotation();
00095 annotation.reset();
00096
00097 std::set< std::string > existingAnnotationItems;
00098 for ( int item = 0; item < annotation.size(); ++item ) {
00099 existingAnnotationItems.insert( annotation.key( item ) );
00100 }
00101 const AIDA::IAnnotation& otherAnnotation = h.annotation();
00102 for ( int itemNew = 0; itemNew < otherAnnotation.size(); ++itemNew ) {
00103 const std::string& key = otherAnnotation.key( itemNew );
00104 if ( existingAnnotationItems.find( key ) == existingAnnotationItems.end() ) {
00105 annotation.addItem( key, otherAnnotation.value( itemNew ), false );
00106 }
00107 }
00108
00109 return p;
00110 }
00111
00112
00113 AIDA::Dev::IDevDataPointSet*
00114 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::create( const AIDA::IHistogram2D & h )
00115 {
00116 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( h.title(), h.dimension() + 1, createAnnotation() );
00117
00118
00119 const AIDA::IAxis& xAxis = h.xAxis();
00120 const AIDA::IAxis& yAxis = h.yAxis();
00121 for ( int i = 0; i < xAxis.bins(); ++i ) {
00122 for ( int j = 0; j < yAxis.bins(); ++j ) {
00123 p->addPoint();
00124 AIDA::IDataPoint* point = p->point( p->size() - 1 );
00125
00126 AIDA::IMeasurement* xMeasurement = point->coordinate( 0 );
00127 xMeasurement->setValue( h.binMeanX( i, j ) );
00128 xMeasurement->setErrorPlus( xAxis.binUpperEdge( i ) - xMeasurement->value() );
00129 xMeasurement->setErrorMinus( xMeasurement->value() - xAxis.binLowerEdge( i ) );
00130
00131 AIDA::IMeasurement* yMeasurement = point->coordinate( 1 );
00132 yMeasurement->setValue( h.binMeanY( i, j ) );
00133 yMeasurement->setErrorPlus( yAxis.binUpperEdge( j ) - yMeasurement->value() );
00134 yMeasurement->setErrorMinus( yMeasurement->value() - yAxis.binLowerEdge( j ) );
00135
00136 AIDA::IMeasurement* zMeasurement = point->coordinate( 2 );
00137 const double height = h.binHeight( i, j );
00138 const double error = h.binError( i, j );
00139 zMeasurement->setValue( height );
00140 zMeasurement->setErrorPlus( error );
00141 zMeasurement->setErrorMinus( error );
00142 }
00143 }
00144
00145
00146 AIDA::IAnnotation& annotation = p->annotation();
00147 annotation.reset();
00148
00149 std::set< std::string > existingAnnotationItems;
00150 for ( int item = 0; item < annotation.size(); ++item ) {
00151 existingAnnotationItems.insert( annotation.key( item ) );
00152 }
00153 const AIDA::IAnnotation& otherAnnotation = h.annotation();
00154 for ( int itemNew = 0; itemNew < otherAnnotation.size(); ++itemNew ) {
00155 const std::string& key = otherAnnotation.key( itemNew );
00156 if ( existingAnnotationItems.find( key ) == existingAnnotationItems.end() ) {
00157 annotation.addItem( key, otherAnnotation.value( itemNew ), false );
00158 }
00159 }
00160
00161 return p;
00162 }
00163
00164
00165 AIDA::Dev::IDevDataPointSet*
00166 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::create( const AIDA::IHistogram3D & h )
00167 {
00168 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( h.title(), h.dimension() + 1, createAnnotation() );
00169
00170
00171 const AIDA::IAxis& xAxis = h.xAxis();
00172 const AIDA::IAxis& yAxis = h.yAxis();
00173 const AIDA::IAxis& zAxis = h.zAxis();
00174 for ( int i = 0; i < xAxis.bins(); ++i ) {
00175 for ( int j = 0; j < yAxis.bins(); ++j ) {
00176 for ( int k = 0; k < zAxis.bins(); ++k ) {
00177 p->addPoint();
00178 AIDA::IDataPoint* point = p->point( p->size() - 1 );
00179
00180 AIDA::IMeasurement* xMeasurement = point->coordinate( 0 );
00181 xMeasurement->setValue( h.binMeanX( i, j, k ) );
00182 xMeasurement->setErrorPlus( xAxis.binUpperEdge( i ) - xMeasurement->value() );
00183 xMeasurement->setErrorMinus( xMeasurement->value() - xAxis.binLowerEdge( i ) );
00184
00185 AIDA::IMeasurement* yMeasurement = point->coordinate( 1 );
00186 yMeasurement->setValue( h.binMeanY( i, j, k ) );
00187 yMeasurement->setErrorPlus( yAxis.binUpperEdge( j ) - yMeasurement->value() );
00188 yMeasurement->setErrorMinus( yMeasurement->value() - yAxis.binLowerEdge( j ) );
00189
00190 AIDA::IMeasurement* zMeasurement = point->coordinate( 2 );
00191 zMeasurement->setValue( h.binMeanZ( i, j, k ) );
00192 zMeasurement->setErrorPlus( zAxis.binUpperEdge( k ) - zMeasurement->value() );
00193 zMeasurement->setErrorMinus( zMeasurement->value() - zAxis.binLowerEdge( k ) );
00194
00195 AIDA::IMeasurement* nMeasurement = point->coordinate( 3 );
00196 const double height = h.binHeight( i, j, k );
00197 const double error = h.binError( i, j, k );
00198 nMeasurement->setValue( height );
00199 nMeasurement->setErrorPlus( error );
00200 nMeasurement->setErrorMinus( error );
00201 }
00202 }
00203 }
00204
00205
00206 AIDA::IAnnotation& annotation = p->annotation();
00207 annotation.reset();
00208
00209 std::set< std::string > existingAnnotationItems;
00210 for ( int item = 0; item < annotation.size(); ++item ) {
00211 existingAnnotationItems.insert( annotation.key( item ) );
00212 }
00213 const AIDA::IAnnotation& otherAnnotation = h.annotation();
00214 for ( int itemNew = 0; itemNew < otherAnnotation.size(); ++itemNew ) {
00215 const std::string& key = otherAnnotation.key( itemNew );
00216 if ( existingAnnotationItems.find( key ) == existingAnnotationItems.end() ) {
00217 annotation.addItem( key, otherAnnotation.value( itemNew ), false );
00218 }
00219 }
00220
00221 return p;
00222 }
00223
00224
00225 AIDA::Dev::IDevDataPointSet*
00226 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::create( const AIDA::ICloud1D & c )
00227 {
00228 if ( c.isConverted() ) return create( c.histogram() );
00229
00230 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( c.title(), c.dimension() + 1, createAnnotation() );
00231 for ( int i = 0; i < c.entries(); ++i ) {
00232 p->addPoint();
00233 AIDA::IDataPoint* point = p->point( p->size() - 1 );
00234 point->coordinate( 0 )->setValue( c.value( i ) );
00235 point->coordinate( 1 )->setValue( c.weight( i ) );
00236 }
00237
00238
00239 AIDA::IAnnotation& annotation = p->annotation();
00240 annotation.reset();
00241
00242 std::set< std::string > existingAnnotationItems;
00243 for ( int item = 0; item < annotation.size(); ++item ) {
00244 existingAnnotationItems.insert( annotation.key( item ) );
00245 }
00246 const AIDA::IAnnotation& otherAnnotation = c.annotation();
00247 for ( int itemNew = 0; itemNew < otherAnnotation.size(); ++itemNew ) {
00248 const std::string& key = otherAnnotation.key( itemNew );
00249 if ( existingAnnotationItems.find( key ) == existingAnnotationItems.end() ) {
00250 annotation.addItem( key, otherAnnotation.value( itemNew ), false );
00251 }
00252 }
00253
00254 return p;
00255 }
00256
00257
00258 AIDA::Dev::IDevDataPointSet*
00259 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::create( const AIDA::ICloud2D & c )
00260 {
00261 if ( c.isConverted() ) return create( c.histogram() );
00262
00263 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( c.title(), c.dimension() + 1, createAnnotation() );
00264 for ( int i = 0; i < c.entries(); ++i ) {
00265 p->addPoint();
00266 AIDA::IDataPoint* point = p->point( p->size() - 1 );
00267 point->coordinate( 0 )->setValue( c.valueX( i ) );
00268 point->coordinate( 1 )->setValue( c.valueY( i ) );
00269 point->coordinate( 2 )->setValue( c.weight( i ) );
00270 }
00271
00272
00273 AIDA::IAnnotation& annotation = p->annotation();
00274 annotation.reset();
00275
00276 std::set< std::string > existingAnnotationItems;
00277 for ( int item = 0; item < annotation.size(); ++item ) {
00278 existingAnnotationItems.insert( annotation.key( item ) );
00279 }
00280 const AIDA::IAnnotation& otherAnnotation = c.annotation();
00281 for ( int itemNew = 0; itemNew < otherAnnotation.size(); ++itemNew ) {
00282 const std::string& key = otherAnnotation.key( itemNew );
00283 if ( existingAnnotationItems.find( key ) == existingAnnotationItems.end() ) {
00284 annotation.addItem( key, otherAnnotation.value( itemNew ), false );
00285 }
00286 }
00287
00288 return p;
00289 }
00290
00291
00292 AIDA::Dev::IDevDataPointSet*
00293 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::create( const AIDA::ICloud3D & c )
00294 {
00295 if ( c.isConverted() ) return create( c.histogram() );
00296
00297 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( c.title(), c.dimension() + 1, createAnnotation() );
00298 for ( int i = 0; i < c.entries(); ++i ) {
00299 p->addPoint();
00300 AIDA::IDataPoint* point = p->point( p->size() - 1 );
00301 point->coordinate( 0 )->setValue( c.valueX( i ) );
00302 point->coordinate( 1 )->setValue( c.valueY( i ) );
00303 point->coordinate( 2 )->setValue( c.valueZ( i ) );
00304 point->coordinate( 3 )->setValue( c.weight( i ) );
00305 }
00306
00307
00308 AIDA::IAnnotation& annotation = p->annotation();
00309 annotation.reset();
00310
00311 std::set< std::string > existingAnnotationItems;
00312 for ( int item = 0; item < annotation.size(); ++item ) {
00313 existingAnnotationItems.insert( annotation.key( item ) );
00314 }
00315 const AIDA::IAnnotation& otherAnnotation = c.annotation();
00316 for ( int itemNew = 0; itemNew < otherAnnotation.size(); ++itemNew ) {
00317 const std::string& key = otherAnnotation.key( itemNew );
00318 if ( existingAnnotationItems.find( key ) == existingAnnotationItems.end() ) {
00319 annotation.addItem( key, otherAnnotation.value( itemNew ), false );
00320 }
00321 }
00322
00323 return p;
00324 }
00325
00326
00327 AIDA::Dev::IDevDataPointSet*
00328 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::create( const AIDA::IProfile1D & h )
00329 {
00330 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( h.title(), h.dimension() + 1, createAnnotation() );
00331
00332
00333 const AIDA::IAxis& xAxis = h.axis();
00334 for ( int i = 0; i < xAxis.bins(); ++i ) {
00335 p->addPoint();
00336 AIDA::IDataPoint* point = p->point(i);
00337 AIDA::IMeasurement* xMeasurement = point->coordinate( 0 );
00338 xMeasurement->setValue( h.binMean( i ) );
00339 xMeasurement->setErrorPlus( xAxis.binUpperEdge( i ) - xMeasurement->value() );
00340 xMeasurement->setErrorMinus( xMeasurement->value() - xAxis.binLowerEdge( i ) );
00341
00342 AIDA::IMeasurement* yMeasurement = point->coordinate( 1 );
00343 const double height = h.binHeight( i );
00344 const double error = h.binRms( i );
00345 yMeasurement->setValue( height );
00346 yMeasurement->setErrorPlus( error );
00347 yMeasurement->setErrorMinus( error );
00348 }
00349
00350
00351 AIDA::IAnnotation& annotation = p->annotation();
00352 annotation.reset();
00353
00354 std::set< std::string > existingAnnotationItems;
00355 for ( int item = 0; item < annotation.size(); ++item ) {
00356 existingAnnotationItems.insert( annotation.key( item ) );
00357 }
00358 const AIDA::IAnnotation& otherAnnotation = h.annotation();
00359 for ( int itemNew = 0; itemNew < otherAnnotation.size(); ++itemNew ) {
00360 const std::string& key = otherAnnotation.key( itemNew );
00361 if ( existingAnnotationItems.find( key ) == existingAnnotationItems.end() ) {
00362 annotation.addItem( key, otherAnnotation.value( itemNew ), false );
00363 }
00364 }
00365
00366 return p;
00367 }
00368
00369
00370 AIDA::Dev::IDevDataPointSet*
00371 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::create( const AIDA::IProfile2D & h )
00372 {
00373 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( h.title(), h.dimension() + 1, createAnnotation() );
00374
00375
00376 const AIDA::IAxis& xAxis = h.xAxis();
00377 const AIDA::IAxis& yAxis = h.yAxis();
00378 for ( int i = 0; i < xAxis.bins(); ++i ) {
00379 for ( int j = 0; j < yAxis.bins(); ++j ) {
00380 p->addPoint();
00381 AIDA::IDataPoint* point = p->point( p->size() - 1 );
00382
00383 AIDA::IMeasurement* xMeasurement = point->coordinate( 0 );
00384 xMeasurement->setValue( h.binMeanX( i, j ) );
00385 xMeasurement->setErrorPlus( xAxis.binUpperEdge( i ) - xMeasurement->value() );
00386 xMeasurement->setErrorMinus( xMeasurement->value() - xAxis.binLowerEdge( i ) );
00387
00388 AIDA::IMeasurement* yMeasurement = point->coordinate( 1 );
00389 yMeasurement->setValue( h.binMeanY( i, j ) );
00390 yMeasurement->setErrorPlus( yAxis.binUpperEdge( j ) - yMeasurement->value() );
00391 yMeasurement->setErrorMinus( yMeasurement->value() - yAxis.binLowerEdge( j ) );
00392
00393 AIDA::IMeasurement* zMeasurement = point->coordinate( 2 );
00394 const double height = h.binHeight( i, j );
00395 const double error = h.binRms( i, j );
00396 zMeasurement->setValue( height );
00397 zMeasurement->setErrorPlus( error );
00398 zMeasurement->setErrorMinus( error );
00399 }
00400 }
00401
00402
00403 AIDA::IAnnotation& annotation = p->annotation();
00404 annotation.reset();
00405
00406 std::set< std::string > existingAnnotationItems;
00407 for ( int item = 0; item < annotation.size(); ++item ) {
00408 existingAnnotationItems.insert( annotation.key( item ) );
00409 }
00410 const AIDA::IAnnotation& otherAnnotation = h.annotation();
00411 for ( int itemNew = 0; itemNew < otherAnnotation.size(); ++itemNew ) {
00412 const std::string& key = otherAnnotation.key( itemNew );
00413 if ( existingAnnotationItems.find( key ) == existingAnnotationItems.end() ) {
00414 annotation.addItem( key, otherAnnotation.value( itemNew ), false );
00415 }
00416 }
00417
00418 return p;
00419 }
00420
00421
00422 AIDA::Dev::IDevDataPointSet*
00423 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::add( const AIDA::IDataPointSet& a,
00424 const AIDA::IDataPointSet& b,
00425 std::string )
00426 {
00427 if ( a.dimension() != b.dimension() || a.size() != b.size() ) return 0;
00428 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( a.title(), a.dimension(), createAnnotation() );
00429 for ( int iPoint = 0; iPoint < a.size(); ++iPoint ) {
00430 p->addPoint();
00431 AIDA::IDataPoint* point = p->point( p->size() - 1 );
00432 const AIDA::IDataPoint* pointA = a.point( iPoint );
00433 const AIDA::IDataPoint* pointB = b.point( iPoint );
00434 for ( int i = 0; i < point->dimension(); ++i ) {
00435 AIDA::IMeasurement* measurement = point->coordinate( i );
00436 const AIDA::IMeasurement* measurementA = pointA->coordinate( i );
00437 const AIDA::IMeasurement* measurementB = pointB->coordinate( i );
00438 const double valueA = measurementA->value();
00439 const double valueB = measurementB->value();
00440 const double errorPlusA = measurementA->errorPlus();
00441 const double errorPlusB = measurementB->errorPlus();
00442 const double errorMinusA = measurementA->errorMinus();
00443 const double errorMinusB = measurementB->errorMinus();
00444
00445 const double value = valueA + valueB;
00446 const double errorPlus = sqrt( errorPlusA*errorPlusA + errorPlusB*errorPlusB );
00447 const double errorMinus = sqrt( errorMinusA*errorMinusA + errorMinusB*errorMinusB );
00448
00449 measurement->setValue( value );
00450 measurement->setErrorPlus( errorPlus );
00451 measurement->setErrorMinus( errorMinus );
00452 }
00453 }
00454
00455 return p;
00456 }
00457
00458
00459 AIDA::Dev::IDevDataPointSet*
00460 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::subtract( const AIDA::IDataPointSet& a,
00461 const AIDA::IDataPointSet& b,
00462 std::string )
00463 {
00464 if ( a.dimension() != b.dimension() || a.size() != b.size() ) return 0;
00465 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( a.title(), a.dimension(), createAnnotation() );
00466 for ( int iPoint = 0; iPoint < a.size(); ++iPoint ) {
00467 p->addPoint();
00468 AIDA::IDataPoint* point = p->point( p->size() - 1 );
00469 const AIDA::IDataPoint* pointA = a.point( iPoint );
00470 const AIDA::IDataPoint* pointB = b.point( iPoint );
00471 for ( int i = 0; i < point->dimension(); ++i ) {
00472 AIDA::IMeasurement* measurement = point->coordinate( i );
00473 const AIDA::IMeasurement* measurementA = pointA->coordinate( i );
00474 const AIDA::IMeasurement* measurementB = pointB->coordinate( i );
00475 const double valueA = measurementA->value();
00476 const double valueB = measurementB->value();
00477 const double errorPlusA = measurementA->errorPlus();
00478 const double errorPlusB = measurementB->errorPlus();
00479 const double errorMinusA = measurementA->errorMinus();
00480 const double errorMinusB = measurementB->errorMinus();
00481
00482 const double value = valueA - valueB;
00483 const double errorPlus = sqrt( errorPlusA*errorPlusA + errorPlusB*errorPlusB );
00484 const double errorMinus = sqrt( errorMinusA*errorMinusA + errorMinusB*errorMinusB );
00485
00486 measurement->setValue( value );
00487 measurement->setErrorPlus( errorPlus );
00488 measurement->setErrorMinus( errorMinus );
00489 }
00490 }
00491
00492 return p;
00493 }
00494
00495
00496 AIDA::Dev::IDevDataPointSet*
00497 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::multiply( const AIDA::IDataPointSet& a,
00498 const AIDA::IDataPointSet& b,
00499 std::string )
00500 {
00501 if ( a.dimension() != b.dimension() || a.size() != b.size() ) return 0;
00502 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( a.title(), a.dimension(), createAnnotation() );
00503 for ( int iPoint = 0; iPoint < a.size(); ++iPoint ) {
00504 p->addPoint();
00505 AIDA::IDataPoint* point = p->point( p->size() - 1 );
00506 const AIDA::IDataPoint* pointA = a.point( iPoint );
00507 const AIDA::IDataPoint* pointB = b.point( iPoint );
00508 for ( int i = 0; i < point->dimension(); ++i ) {
00509 AIDA::IMeasurement* measurement = point->coordinate( i );
00510 const AIDA::IMeasurement* measurementA = pointA->coordinate( i );
00511 const AIDA::IMeasurement* measurementB = pointB->coordinate( i );
00512 const double valueA = measurementA->value();
00513 const double valueB = measurementB->value();
00514 const double errorPlusA = measurementA->errorPlus();
00515 const double errorPlusB = measurementB->errorPlus();
00516 const double errorMinusA = measurementA->errorMinus();
00517 const double errorMinusB = measurementB->errorMinus();
00518
00519 const double value = valueA * valueB;
00520 const double errorPlus = sqrt( errorPlusA*errorPlusA*valueB*valueB + errorPlusB*errorPlusB*valueA*valueA );
00521 const double errorMinus = sqrt( errorMinusA*errorMinusA*valueB*valueB + errorMinusB*errorMinusB*valueA*valueA );
00522
00523 measurement->setValue( value );
00524 measurement->setErrorPlus( errorPlus );
00525 measurement->setErrorMinus( errorMinus );
00526 }
00527 }
00528
00529 return p;
00530 }
00531
00532
00533 AIDA::Dev::IDevDataPointSet*
00534 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::divide( const AIDA::IDataPointSet& a,
00535 const AIDA::IDataPointSet& b,
00536 std::string )
00537 {
00538 if ( a.dimension() != b.dimension() || a.size() != b.size() ) return 0;
00539 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( a.title(), a.dimension(), createAnnotation() );
00540 for ( int iPoint = 0; iPoint < a.size(); ++iPoint ) {
00541 p->addPoint();
00542 AIDA::IDataPoint* point = p->point( p->size() - 1 );
00543 const AIDA::IDataPoint* pointA = a.point( iPoint );
00544 const AIDA::IDataPoint* pointB = b.point( iPoint );
00545 for ( int i = 0; i < point->dimension(); ++i ) {
00546 AIDA::IMeasurement* measurement = point->coordinate( i );
00547 const AIDA::IMeasurement* measurementA = pointA->coordinate( i );
00548 const AIDA::IMeasurement* measurementB = pointB->coordinate( i );
00549 const double valueA = measurementA->value();
00550 const double valueB = measurementB->value();
00551 const double errorPlusA = measurementA->errorPlus();
00552 const double errorPlusB = measurementB->errorPlus();
00553 const double errorMinusA = measurementA->errorMinus();
00554 const double errorMinusB = measurementB->errorMinus();
00555
00556 double value = 0;
00557 double errorPlus = 0;
00558 double errorMinus = 0;
00559 if ( valueB != 0 ) {
00560 value = valueA / valueB;
00561 const double valueA2 = valueA * valueA;
00562 const double valueB2 = valueB * valueB;
00563 const double valueB4 = valueB2 * valueB2;
00564 errorPlus = sqrt( errorPlusA * errorPlusA / valueB2 + errorPlusB * errorPlusB * valueA2 / valueB4 );
00565 errorMinus = sqrt( errorMinusA * errorMinusA / valueB2 + errorMinusB * errorMinusB * valueA2 / valueB4 );
00566 }
00567
00568 measurement->setValue( value );
00569 measurement->setErrorPlus( errorPlus );
00570 measurement->setErrorMinus( errorMinus );
00571 }
00572 }
00573
00574 return p;
00575 }
00576
00577
00578 AIDA::Dev::IDevDataPointSet*
00579 Anaphe::AIDA_DataPointSet_native::AIDA_DevDataPointSetFactory::weightedMean( const AIDA::IDataPointSet& a,
00580 const AIDA::IDataPointSet& b,
00581 std::string )
00582 {
00583 if ( a.dimension() != b.dimension() || a.size() != b.size() ) return 0;
00584 AIDA::Dev::IDevDataPointSet* p = new Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet( a.title(), a.dimension(), createAnnotation() );
00585 for ( int iPoint = 0; iPoint < a.size(); ++iPoint ) {
00586 p->addPoint();
00587 AIDA::IDataPoint* point = p->point( p->size() - 1 );
00588 const AIDA::IDataPoint* pointA = a.point( iPoint );
00589 const AIDA::IDataPoint* pointB = b.point( iPoint );
00590 for ( int i = 0; i < point->dimension(); ++i ) {
00591 AIDA::IMeasurement* measurement = point->coordinate( i );
00592 const AIDA::IMeasurement* measurementA = pointA->coordinate( i );
00593 const AIDA::IMeasurement* measurementB = pointB->coordinate( i );
00594 const double valueA = measurementA->value();
00595 const double valueB = measurementB->value();
00596 const double errorPlusA = measurementA->errorPlus();
00597 const double errorPlusB = measurementB->errorPlus();
00598 const double errorMinusA = measurementA->errorMinus();
00599 const double errorMinusB = measurementB->errorMinus();
00600
00601
00602 const double errorA2 = 0.5 * ( errorPlusA*errorPlusA + errorMinusA*errorMinusA );
00603 const double errorB2 = 0.5 * ( errorPlusB*errorPlusB + errorMinusB*errorMinusB );
00604
00605 double value = 0;
00606 double error = 0;
00607 if ( errorA2 != 0 && errorB2 != 0 ) {
00608 const double wA = 1 / errorA2;
00609 const double wB = 1 / errorB2;
00610 value = ( valueA * wA + valueB * wB ) / ( wA + wB );
00611 error = ( sqrt( wA ) + sqrt( wB ) ) / ( wA + wB );
00612 }
00613
00614 measurement->setValue( value );
00615 measurement->setErrorPlus( error );
00616 measurement->setErrorMinus( error );
00617 }
00618 }
00619
00620 return p;
00621 }