title: error: cannot allocate an object of abstract type
body: <p>As much as I want to create an MVCE of this problem...I really can't. I am using an open source fluid flow solver called Palabos with its dev guide also available . It is based on generic structures and mpi. Probably the best available open source solver of its kind</p>
  
  <p>The developers there use Box Processors for cycling through arrays(generally speaking..it can be tensors, lattice are other objects). Here is a way they use processors for a single lattice case</p>
  
  <pre><code>struct IniTemperatureRayleighBenardProcessor2D :
      public BoxProcessingFunctional2D_L&lt;T,adDescriptor&gt;
  {
      IniTemperatureRayleighBenardProcessor2D(RayleighBenardFlowParam&lt;T,nsDescriptor,adDescriptor&gt; parameters_)
          : parameters(parameters_)
      { }
      virtual void process(Box2D domain, BlockLattice2D&lt;T,adDescriptor&gt;&amp; adLattice)
      {
          Dot2D absoluteOffset = adLattice.getLocation();
          Array&lt;T,adDescriptor&lt;T&gt;::d&gt; jEq(0.0, 0.0);
  
      for (plint iX=domain.x0; iX&lt;=domain.x1; ++iX) {
          for (plint iY=domain.y0; iY&lt;=domain.y1; ++iY) {
  //some operations...............
          }
      }
      }
      virtual IniTemperatureRayleighBenardProcessor2D&lt;T,nsDescriptor,adDescriptor&gt;* clone() const
      {
          return new IniTemperatureRayleighBenardProcessor2D&lt;T,nsDescriptor,adDescriptor&gt;(*this);
  }
  
  virtual void getTypeOfModification(std::vector&lt;modif::ModifT&gt;&amp; modified) const {
      modified[0] = modif::staticVariables;
  }
  
  virtual BlockDomain::DomainT appliesTo() const {
      return BlockDomain::bulkAndEnvelope;
  }
  
  private :
      RayleighBenardFlowParam&lt;T,nsDescriptor,adDescriptor&gt; parameters;
  };
  </code></pre>
  
  <p>Here how they call it</p>
  
  <pre><code>   applyProcessingFunctional (
              new IniTemperatureRayleighBenardProcessor2D&lt;T,NSDESCRIPTOR,ADESCRIPTOR&gt;(parameters), adLattice.getBoundingBox(),
              adLattice );
  </code></pre>
  
  <p>Details of the whole procedure are at (<a href="http://www.palabos.org/documentation/userguide/data-processors.html" rel="nofollow">http://www.palabos.org/documentation/userguide/data-processors.html</a>)</p>
  
  <p>with related source code at (<a href="http://www.palabos.org/documentation/develguide/dataProcessingFunctional2D_8h_source.html" rel="nofollow">http://www.palabos.org/documentation/develguide/dataProcessingFunctional2D_8h_source.html</a>)</p>
  
  <p>Now, here is my problem.
  I am using a similar data processor to perform operation on two scalar arrays. Tried to understand as much as of the source code as possible</p>
  
  <pre><code>template&lt;typename T1, typename T2&gt;
  //template&lt;typename T, template&lt;typename NSU&gt; class nsDescriptor,
  //                     template&lt;typename ADU&gt; class adDescriptor, typename T1, typename T2&gt;
  struct IniFluxMultiplier2D :
      public BoxProcessingFunctional2D_SS&lt;T,T&gt;
  {
      IniFluxMultiplier2D(RayleighBenardFlowParam&lt;T,NSDESCRIPTOR,ADESCRIPTOR&gt; parameters_)
          : parameters(parameters_)
      { }
      virtual void process(Box2D domain,
                           MultiScalarField2D&lt;bool&gt;&amp; boolMask,
                           MultiScalarField2D&lt;T&gt; &amp;FluxMultiplier)
          {
          //Dot2D absoluteOffset = adLattice.getLocation();
          //Array&lt;T,adDescriptor&lt;T&gt;::d&gt; jEq(0.0, 0.0);
  
          for (plint iX=domain.x0; iX&lt;=domain.x1; ++iX) {
              for (plint iY=domain.y0; iY&lt;=domain.y1; ++iY) {
                  //plint absoluteX = absoluteOffset.x + iX;
                  //plint absoluteY = absoluteOffset.y + iY;
                  bool  solidblock = boolMask.get(iX,iY);
  
                  if(solidblock== true){
                  FluxMultiplier.get(iX,iY)=(parameters.getTemperatureTau()-(T)0.5)/parameters.getTemperatureTau();}
                  else{
                  FluxMultiplier.get(iX,iY)=(parameters.getSolventTau()-(T)0.5)/parameters.getSolventTau();}
  
          }
      }
      }
     virtual IniFluxMultiplier2D&lt;T1,T2&gt;* clone() const
      {
          return new IniFluxMultiplier2D&lt;T1,T2&gt;(*this);
      }
  
     virtual void getTypeOfModification(std::vector&lt;modif::ModifT&gt;&amp; modified) const {
          modified[0] = modif::staticVariables;
      }
  
      virtual BlockDomain::DomainT appliesTo() const {
          return BlockDomain::bulkAndEnvelope;
      }
  
  private :
      RayleighBenardFlowParam&lt;T,NSDESCRIPTOR,ADESCRIPTOR&gt; parameters;
  };
  </code></pre>
  
  <p>and here is how I call it</p>
  
  <pre><code>applyProcessingFunctional (
          new IniFluxMultiplier2D&lt;T,T&gt;(parameters), boolMask.getBoundingBox(), boolMask,FluxMultiplier);
  </code></pre>
  
  <p>I am getting the error</p>
  
  <pre><code>error: cannot allocate an object of abstract type ‘IniFluxMultiplier2D&lt;double, double&gt;’|
  </code></pre>
  
  <p>Tried debugging it but I am stuck and really can't figure a way out. I don't really expect anyone to run this, but I know I am making a conceptual mistake at the starting of the structure which I can't really figure out.</p>
  
  <p>T is decalared as </p>
  
  <pre><code>typedef double T;
  </code></pre>
  
  <p>globally</p>