Main Page   Namespace List   Alphabetical List   Compound List   File List   Compound Members   File Members  

AIDA_DevDataPointSetFactory.cpp

Go to the documentation of this file.
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   // Copy the data
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   // Copy the annotation items
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   // Copy the data
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   // Copy the annotation items
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   // Copy the data
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   // Copy the annotation items
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   // Copy the annotation items
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   // Copy the annotation items
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   // Copy the annotation items
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   // Copy the data
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   // Copy the annotation items
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   // Copy the data
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   // Copy the annotation items
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 = std::sqrt( errorPlusA*errorPlusA + errorPlusB*errorPlusB );
00447       const double errorMinus = std::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 = std::sqrt( errorPlusA*errorPlusA + errorPlusB*errorPlusB );
00484       const double errorMinus = std::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 = std::sqrt( errorPlusA*errorPlusA*valueB*valueB + errorPlusB*errorPlusB*valueA*valueA );
00521       const double errorMinus = std::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 = std::sqrt( errorPlusA * errorPlusA / valueB2 + errorPlusB * errorPlusB * valueA2 / valueB4 );
00565         errorMinus = std::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       // We will assume symmetric errors
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 = ( std::sqrt( wA ) + std::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 }

Generated on Tue Feb 18 17:50:27 2003 for AIDA_DataPointSet_native by doxygen1.2.16