Polygonal wire antenna now uses std::move realizing some perf. benefits.

Modules/FDEM1D/include/KernelEM1DReflBase.h

                 Zyi = VectorXcr::Zero(nlay);
                 th = VectorXcr::Zero(nlay);
 
-                // Don't attach Earth, because this is performance critical.
-                // Everying is internal, it's OK relax Frankie
-                //if (Earth != NULL) {
-                //    Earth->DetachFrom(this);
-                //    Earth = NULL;
-                //}
-                //EarthIn->AttachTo(this);
                 Earth = EarthIn;
 
                 LayerThickness.resize(nlay);
 			VectorXr     LayerThickness;
 			VectorXr     LayerDepth;
 
-			/// Reflection/Transmission coeffients for upgoing waves in a
+			/// Reflection/Transmission coef. for upgoing waves in a
 			/// layered earth model
 			VectorXcr    rtu;
 
-			/// Reflection/Transmission coeffients for downgoing waves in
+			/// Reflection/Transmission coef. for downgoing waves in
 			/// a layered earth model
 			VectorXcr    rtd;
 

Modules/FDEM1D/include/PolygonalWireAntenna.h

   @file
   @author   Trevor Irons
   @date     05/18/2010
-  @version  $Id: PolygonalWireAntenna.h 211 2015-02-27 05:43:26Z tirons $
  **/
 #ifndef  POLYGONALWIREANTENNA_INC
 #define  POLYGONALWIREANTENNA_INC
                             const Vector3r &rp);
 
             /// Interpolates dipoles along line segment defined by p0 and p1.
-            void InterpolateLineSegment(const Vector3r &p0, const Vector3r &p1,
-                            const Vector3r &rp);
-
-
-            /// List of the dipoles
-            //std::vector<DipoleSource*>           Dipoles;
-
-            /// Points that define this loop
-            //Vector3Xr                            Points;
+            void InterpolateLineSegment(const Vector3r &p0, const Vector3r &p1, const Vector3r &rp,
+                            std::vector< std::shared_ptr<DipoleSource> > &Dipoles );
 
         private:
 

Modules/FDEM1D/src/PolygonalWireAntenna.cpp

         if ( (rRepeat-rp).norm() > 1e-16 ) {
 		    Dipoles.clear();
 
+            ///////////////////
+		    // dipole array, this has impoved performance over directly pushing
+		    std::vector< std::shared_ptr<DipoleSource> >       xDipoles;
+
 		    // loop over all segments
 		    for (int iseg=0; iseg<NumberOfPoints-1; ++iseg) {
-			    InterpolateLineSegment(Points.col(iseg), Points.col(iseg+1), rp);
+			    InterpolateLineSegment(Points.col(iseg), Points.col(iseg+1), rp, xDipoles);
 		    }
+            Dipoles = std::move(xDipoles);
             rRepeat = rp;
 
         } else {
 	}
 
 	void PolygonalWireAntenna::InterpolateLineSegment(const Vector3r &p1,
-					const Vector3r &p2, const Vector3r & tp) {
-
+					const Vector3r &p2, const Vector3r & tp,
+					std::vector< std::shared_ptr<DipoleSource> > &xDipoles ) {
 
 		Vector3r phat = (p1-p2).array() / (p1-p2).norm();
 		Vector3r c    = this->ClosestPointOnLine(p1, p2, tp);
         // unit vector
 		Vector3r cdir = (p2-p1).array() / (p2-p1).norm();
 
-		///////////////////
-		// dipoles for this segment
-		std::vector< std::shared_ptr<DipoleSource> >       xDipoles;
-
 		// go towards p1
 		if ( ((c-p1).array().abs() > minDipoleMoment).any() ) {
 
 			}
 			// else case 0: nearly 'perfect' fit do nothing
 		}
-		Dipoles.insert(Dipoles.end(), xDipoles.begin(), xDipoles.end());
-	}
 
+        //Dipoles.insert(Dipoles.end(), xDipoles.begin(), xDipoles.end());
+        //Dipoles = xDipoles;
+        //xDipoles.clear();
+
+	}
 
 }