dune-fem  2.6-git
createpass.hh
Go to the documentation of this file.
1 #ifndef DUNE_FEM_CREATEPASS_HH
2 #define DUNE_FEM_CREATEPASS_HH
3 
4 #include <memory>
5 
9 
10 namespace Dune
11 {
12 
13  namespace Fem
14  {
15 
37  template< class Model , template <class,class,int> class PassType , int pId = -1 >
38  class CreatePass
39  {
40  public:
42  enum { passId = pId };
43 
45  typedef typename Model :: Traits :: DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
47  typedef typename Model :: Traits :: DiscreteFunctionType DestinationType;
48 
51  protected:
52  Model& model_;
53  std::shared_ptr< const DiscreteFunctionSpaceType > space_;
55 
56  public:
60  CreatePass ( Model &model, const DiscreteFunctionSpaceType &space )
61  : model_( model ), space_( referenceToSharedPtr( space ) )
62  {}
63 
67  CreatePass ( const Model &model, const DiscreteFunctionSpaceType &space )
68  : CreatePass( const_cast< Model & >( model ), space )
69  {}
70 
72  CreatePass ( const CreatePass & ) = default;
73 
75  template <class PreviousPass>
78  {
79  typedef PassType< Model , PreviousPass , passId > RealPassType;
80  typedef SpaceOperatorPtr<RealPassType> ObjPtrType;
81  // create pass
82  RealPassType* pass = new RealPassType(model_,prevObj->pass(), *space_);
83 
84  // create pass storage
85  ObjPtrType* obj = new ObjPtrType(pass);
86 
87  // remember pass obj
88  passPointer_ = obj;
89 
90  // remember previous object for delete
91  obj->saveObjPointer(prevObj);
92  return obj;
93  }
94 
96  template <class PreviousPass>
99  {
100  typedef PassType< Model , PreviousPass , passId > RealPassType;
101  typedef SpaceOperatorWrapper<RealPassType> ObjPtrType;
102  // create pass
103  RealPassType* pass = new RealPassType(model_,prevObj->pass(), *space_);
104 
105  // create pass storage
106  ObjPtrType* obj = new ObjPtrType(pass);
107 
108  // remember pass obj
109  passPointer_ = obj;
110 
111  // remember previous object for delete
112  obj->saveObjPointer(prevObj);
113  return obj;
114  }
115 
118  {
119  assert( passPointer_ );
120  return passPointer_;
121  }
122 
125  {
126  assert( passPointer_ );
127  return passPointer_->destination();
128  }
129  };
130 
131 
133  template <class DiscreteModelImp, class SelectorImp>
135  : public ObjPointerStorage,
136  public DiscreteModelImp
137  {
138  // type of base class
139  typedef DiscreteModelImp BaseType;
140  public:
142  typedef SelectorImp SelectorType;
144  DiscreteModelWrapper(const BaseType& base)
145  : BaseType(base) // calling copy constructor of base
146  {}
147 
150  : BaseType(other) // calling copy constructor of base
151  {}
152  };
153 
155  template <class Model, class SelectorImp, template <class,class> class PassType>
157  {
158  public:
160  typedef typename Model :: Traits :: DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
162  typedef typename Model :: Traits :: DiscreteFunctionType DestinationType;
163 
166 
169  protected:
171  std::shared_ptr< const DiscreteFunctionSpaceType > space_;
173  bool owner_ = true;
174 
175  public:
179  CreateSelectedPass(Model& model, const DiscreteFunctionSpaceType& space)
180  : model_(new DiscreteModelType(model)), space_( referenceToSharedPtr( space ) )
181  {}
182 
185  : model_(new DiscreteModelType(org.model_)),
186  space_(org.space_),
188  {}
189 
192  {
193  if( owner_ ) delete model_;
194  model_ = nullptr;
195  }
196 
198  template <class PreviousPass>
201  {
202  typedef PassType<DiscreteModelType,PreviousPass> RealPassType;
203  typedef SpaceOperatorPtr<RealPassType> ObjPtrType;
204  // create pass
205  RealPassType* pass = new RealPassType(*model_,prevObj->pass(), *space_);
206 
207  // create pass storage
208  ObjPtrType* obj = new ObjPtrType(pass, model_ );
209 
210  // don't delete model anymore
211  owner_ = false;
212 
213  // remember pass obj
214  passPointer_ = obj;
215 
216  // remember previous object for delete
217  obj->saveObjPointer(prevObj);
218  return obj;
219  }
220 
222  template <class PreviousPass>
225  {
226  typedef PassType<DiscreteModelType,PreviousPass> RealPassType;
227  typedef SpaceOperatorWrapper<RealPassType> ObjPtrType;
228  // create pass
229  RealPassType* pass = new RealPassType(*model_,prevObj->pass(), *space_);
230 
231  // create pass storage
232  ObjPtrType* obj = new ObjPtrType(pass, model_);
233 
234  // don't delete model anymore
235  owner_ = false;
236 
237  // remember pass obj
238  passPointer_ = obj;
239 
240  // remember previous object for delete
241  obj->saveObjPointer(prevObj);
242  return obj;
243  }
244 
247  {
248  assert( passPointer_ );
249  return passPointer_;
250  }
251 
254  {
255  assert( passPointer_ );
256  return passPointer_->destination();
257  }
258  };
259 
265  template <class Model, template <class,class,int> class PassType,
266  class SpaceType, // = typename Model :: Traits :: DiscreteFunctionSpaceType ,
267  int pId
268  >
270  {
271  public:
273  enum { passId = pId };
274 
276  typedef SpaceType DiscreteFunctionSpaceType;
278  typedef typename Model :: Traits :: DiscreteFunctionType DestinationType;
279 
282  protected:
283  Model& model_;
284  std::shared_ptr< DiscreteFunctionSpaceType > space_;
285  const std::string paramFile_;
287 
288  public:
293  CreateFeaturedPass(Model& model, DiscreteFunctionSpaceType& space, std::string paramfile = "")
294  : model_(model),
295  space_( referenceToSharedPtr( space) ),
296  paramFile_(paramfile)
297  {}
298 
300  CreateFeaturedPass ( const CreateFeaturedPass & ) = default;
301 
303  template <class PreviousPass>
306  {
307  typedef PassType<Model,PreviousPass,passId> RealPassType;
308  typedef SpaceOperatorPtr<RealPassType> ObjPtrType;
309  // create pass
310  RealPassType* pass = new RealPassType(model_,prevObj->pass(), *space_,paramFile_);
311 
312  // create pass storage
313  ObjPtrType* obj = new ObjPtrType(pass);
314 
315  // remember pass obj
316  passPointer_ = obj;
317 
318  // remember previous object for delete
319  obj->saveObjPointer(prevObj);
320  return obj;
321  }
322 
324  template <class PreviousPass>
327  {
328  typedef PassType<Model,PreviousPass,passId> RealPassType;
329  typedef SpaceOperatorWrapper<RealPassType> ObjPtrType;
330  // create pass
331  RealPassType* pass = new RealPassType(model_,prevObj->pass(), *space_,paramFile_);
332 
333  // create pass storage
334  ObjPtrType* obj = new ObjPtrType(pass);
335 
336  // remember pass obj
337  passPointer_ = obj;
338 
339  // remember previous object for delete
340  obj->saveObjPointer(prevObj);
341  return obj;
342  }
343 
346  {
347  assert( passPointer_ );
348  return passPointer_->destination();
349  }
350  };
351 
356  template <int startPassId = -1>
358  {
359  protected:
361  template <class DestinationType>
363  {
364  typedef StartPass<DestinationType, startPassId> StartPassType;
365  typedef SpaceOperatorStorage<StartPassType> ObjPtrType;
366 
367  // create start pass
368  StartPassType* startPass = new StartPassType ();
369 
370  // create pass storage
371  ObjPtrType* obj = new ObjPtrType(startPass);
372 
373  // return obj
374  return obj;
375  }
376 
377  public:
379  template <class LastModel>
381  create(LastModel& ml)
382  {
383  return ml.createLast( createStartPass<typename LastModel :: DestinationType> () );
384  }
385 
387  template <class FirstModel,
388  class LastModel>
390  create(FirstModel& mf,
391  LastModel& ml)
392  {
393  return ml.createLast( mf.create( createStartPass<typename LastModel :: DestinationType>() ) );
394  }
395 
397  template <class Mod0,
398  class Mod1,
399  class LastModel>
401  create(Mod0& m0,
402  Mod1& m1,
403  LastModel& mlast)
404  {
405  return mlast.createLast(
406  m1.create(
407  m0.create( createStartPass<typename LastModel :: DestinationType> () )
408  )
409  );
410  }
411 
413  template <class Mod0,
414  class Mod1,
415  class Mod2,
416  class LastModel>
418  create(Mod0& m0,
419  Mod1& m1,
420  Mod2& m2,
421  LastModel& mlast)
422  {
423  return mlast.createLast( m2.create( m1.create(
424  m0.create( createStartPass<typename LastModel :: DestinationType> () )
425  ) ) );
426  }
427 
429  template <class Mod0,
430  class Mod1,
431  class Mod2,
432  class Mod3,
433  class LastModel>
435  create(Mod0& m0,
436  Mod1& m1,
437  Mod2& m2,
438  Mod3& m3,
439  LastModel& mlast)
440  {
441  return
442  mlast.createLast(
443  m3.create(
444  m2.create(
445  m1.create(
446  m0.create( createStartPass<typename LastModel :: DestinationType> () )
447  ))));
448  }
449 
451  template <class Mod0,
452  class Mod1,
453  class Mod2,
454  class Mod3,
455  class Mod4,
456  class LastModel>
458  create(Mod0& m0,
459  Mod1& m1,
460  Mod2& m2,
461  Mod3& m3,
462  Mod4& m4,
463  LastModel& mlast)
464  {
465  return
466  mlast.createLast(
467  m4.create(
468  m3.create(
469  m2.create(
470  m1.create(
471  m0.create( createStartPass<typename LastModel :: DestinationType> () )
472  )))) );
473  }
475  template <class Mod0,
476  class Mod1,
477  class Mod2,
478  class Mod3,
479  class Mod4,
480  class Mod5,
481  class LastModel>
483  create(Mod0& m0,
484  Mod1& m1,
485  Mod2& m2,
486  Mod3& m3,
487  Mod4& m4,
488  Mod5& m5,
489  LastModel& mlast)
490  {
491  return
492  mlast.createLast(
493  m5.create(
494  m4.create(
495  m3.create(
496  m2.create(
497  m1.create(
498  m0.create( createStartPass<typename LastModel :: DestinationType> () )
499  )))) ));
500  }
501 
503  template <class Mod0,
504  class Mod1,
505  class Mod2,
506  class Mod3,
507  class Mod4,
508  class Mod5,
509  class Mod6,
510  class LastModel>
512  create(Mod0& m0,
513  Mod1& m1,
514  Mod2& m2,
515  Mod3& m3,
516  Mod4& m4,
517  Mod5& m5,
518  Mod6& m6,
519  LastModel& mlast)
520  {
521  return
522  mlast.createLast(
523  m6.create(
524  m5.create(
525  m4.create(
526  m3.create(
527  m2.create(
528  m1.create(
529  m0.create( createStartPass<typename LastModel :: DestinationType> () )
530  )))) )));
531  }
533  template <class Mod0,
534  class Mod1,
535  class Mod2,
536  class Mod3,
537  class Mod4,
538  class Mod5,
539  class Mod6,
540  class Mod7,
541  class LastModel>
543  create(Mod0& m0,
544  Mod1& m1,
545  Mod2& m2,
546  Mod3& m3,
547  Mod4& m4,
548  Mod5& m5,
549  Mod6& m6,
550  Mod7& m7,
551  LastModel& mlast)
552  {
553  return
554  mlast.createLast(
555  m7.create(
556  m6.create(
557  m5.create(
558  m4.create(
559  m3.create(
560  m2.create(
561  m1.create(
562  m0.create( createStartPass<typename LastModel :: DestinationType> () )
563  )))) ))));
564  }
565  };
566 
567  } // namespace Fem
568 
569 } // namespace Dune
570 #endif // #ifndef DUNE_FEM_CREATEPASS_HH
Definition: bindguard.hh:11
static std::shared_ptr< T > referenceToSharedPtr(T &t)
Definition: memory.hh:19
Definition: objpointer.hh:42
interface for time evolution operators
Definition: spaceoperatorif.hh:105
virtual const DestinationType * destination() const
return reference to pass's local memory
Definition: spaceoperatorif.hh:208
only for keeping the pointer
Definition: spaceoperatorif.hh:215
OperatorType & pass() const
return reference to pass
Definition: spaceoperatorif.hh:246
only for keeping the pointer
Definition: spaceoperatorif.hh:258
apply wrapper
Definition: spaceoperatorif.hh:320
End marker for a compile-time list of passes.
Definition: common/pass.hh:47
CreatePass takes a discrete model and a PassType (like LocalDGPass) and creates with the parameter Pr...
Definition: createpass.hh:39
SpaceOperatorInterface< DestinationType > SpaceOperatorIFType
type of space operator
Definition: createpass.hh:50
Model ::Traits ::DiscreteFunctionType DestinationType
destination type
Definition: createpass.hh:47
CreatePass(Model &model, const DiscreteFunctionSpaceType &space)
Definition: createpass.hh:60
CreatePass(const Model &model, const DiscreteFunctionSpaceType &space)
Definition: createpass.hh:67
std::shared_ptr< const DiscreteFunctionSpaceType > space_
Definition: createpass.hh:53
SpaceOperatorIFType * passPointer_
Definition: createpass.hh:54
Model & model_
Definition: createpass.hh:52
CreatePass(const CreatePass &)=default
copy constructor
const DestinationType * destination() const
return pointer to destination
Definition: createpass.hh:124
Model ::Traits ::DiscreteFunctionSpaceType DiscreteFunctionSpaceType
type of discrete function space
Definition: createpass.hh:45
SpaceOperatorPtr< PassType< Model, PreviousPass, passId > > * create(SpaceOperatorStorage< PreviousPass > *prevObj)
creation method
Definition: createpass.hh:77
SpaceOperatorIFType * pass()
return pointer to space operator if
Definition: createpass.hh:117
SpaceOperatorWrapper< PassType< Model, PreviousPass, passId > > * createLast(SpaceOperatorStorage< PreviousPass > *prevObj)
last creation method
Definition: createpass.hh:98
@ passId
Definition: createpass.hh:42
DiscreteModelWrapper to combine DiscreteModel and Selector.
Definition: createpass.hh:137
DiscreteModelWrapper(const DiscreteModelWrapper &other)
copy constructor
Definition: createpass.hh:149
DiscreteModelWrapper(const BaseType &base)
constructor calling the copy constructor of the base type
Definition: createpass.hh:144
SelectorImp SelectorType
exporting given type of selector
Definition: createpass.hh:142
create pass with previous unknown selector
Definition: createpass.hh:157
DiscreteModelWrapper< Model, SelectorImp > DiscreteModelType
type of discrete model
Definition: createpass.hh:168
Model ::Traits ::DiscreteFunctionType DestinationType
destination type
Definition: createpass.hh:162
SpaceOperatorWrapper< PassType< DiscreteModelType, PreviousPass > > * createLast(SpaceOperatorStorage< PreviousPass > *prevObj)
last creation method
Definition: createpass.hh:224
SpaceOperatorInterface< DestinationType > SpaceOperatorIFType
type of space operator
Definition: createpass.hh:165
~CreateSelectedPass()
destructor deleting model if still owner
Definition: createpass.hh:191
std::shared_ptr< const DiscreteFunctionSpaceType > space_
Definition: createpass.hh:171
DiscreteModelType * model_
Definition: createpass.hh:170
bool owner_
Definition: createpass.hh:173
CreateSelectedPass(Model &model, const DiscreteFunctionSpaceType &space)
Definition: createpass.hh:179
SpaceOperatorIFType * passPointer_
Definition: createpass.hh:172
SpaceOperatorPtr< PassType< DiscreteModelType, PreviousPass > > * create(SpaceOperatorStorage< PreviousPass > *prevObj)
creation method
Definition: createpass.hh:200
const DestinationType * destination() const
return pointer to destination
Definition: createpass.hh:253
Model ::Traits ::DiscreteFunctionSpaceType DiscreteFunctionSpaceType
type of discrete function space
Definition: createpass.hh:160
SpaceOperatorIFType * pass()
return pointer to space operator if
Definition: createpass.hh:246
CreateSelectedPass(const CreateSelectedPass &org)
copy constructor
Definition: createpass.hh:184
CreateFeaturedPass takes a discrete model and a PassType (like LocalDGEllliptPass) and creates with t...
Definition: createpass.hh:270
SpaceOperatorPtr< PassType< Model, PreviousPass, passId > > * create(SpaceOperatorStorage< PreviousPass > *prevObj)
creation method
Definition: createpass.hh:305
SpaceType DiscreteFunctionSpaceType
type of discrete functions space
Definition: createpass.hh:276
SpaceOperatorInterface< DestinationType > SpaceOperatorIFType
type of space operator
Definition: createpass.hh:281
@ passId
Definition: createpass.hh:273
const DestinationType * destination() const
return pointer to destination
Definition: createpass.hh:345
Model & model_
Definition: createpass.hh:283
SpaceOperatorIFType * passPointer_
Definition: createpass.hh:286
SpaceOperatorWrapper< PassType< Model, PreviousPass, passId > > * createLast(SpaceOperatorStorage< PreviousPass > *prevObj)
last creation method
Definition: createpass.hh:326
CreateFeaturedPass(const CreateFeaturedPass &)=default
copy constructor
Model ::Traits ::DiscreteFunctionType DestinationType
destination type
Definition: createpass.hh:278
CreateFeaturedPass(Model &model, DiscreteFunctionSpaceType &space, std::string paramfile="")
Definition: createpass.hh:293
const std::string paramFile_
Definition: createpass.hh:285
std::shared_ptr< DiscreteFunctionSpaceType > space_
Definition: createpass.hh:284
create pass tree from given list of discrete models the passId is deliviered to the start pass and st...
Definition: createpass.hh:358
static SpaceOperatorInterface< typename LastModel ::DestinationType > * create(FirstModel &mf, LastModel &ml)
create 2 passes
Definition: createpass.hh:390
static SpaceOperatorInterface< typename LastModel ::DestinationType > * create(Mod0 &m0, Mod1 &m1, Mod2 &m2, Mod3 &m3, Mod4 &m4, Mod5 &m5, LastModel &mlast)
create 7 passes
Definition: createpass.hh:483
static SpaceOperatorStorage< StartPass< DestinationType, startPassId > > * createStartPass()
method that creates first pass
Definition: createpass.hh:362
static SpaceOperatorInterface< typename LastModel ::DestinationType > * create(Mod0 &m0, Mod1 &m1, Mod2 &m2, Mod3 &m3, Mod4 &m4, Mod5 &m5, Mod6 &m6, Mod7 &m7, LastModel &mlast)
create 9 passes
Definition: createpass.hh:543
static SpaceOperatorInterface< typename LastModel ::DestinationType > * create(LastModel &ml)
create 1 pass
Definition: createpass.hh:381
static SpaceOperatorInterface< typename LastModel ::DestinationType > * create(Mod0 &m0, Mod1 &m1, LastModel &mlast)
create 3 passes
Definition: createpass.hh:401
static SpaceOperatorInterface< typename LastModel ::DestinationType > * create(Mod0 &m0, Mod1 &m1, Mod2 &m2, Mod3 &m3, Mod4 &m4, Mod5 &m5, Mod6 &m6, LastModel &mlast)
create 8 passes
Definition: createpass.hh:512
static SpaceOperatorInterface< typename LastModel ::DestinationType > * create(Mod0 &m0, Mod1 &m1, Mod2 &m2, Mod3 &m3, LastModel &mlast)
create 5 passes
Definition: createpass.hh:435
static SpaceOperatorInterface< typename LastModel ::DestinationType > * create(Mod0 &m0, Mod1 &m1, Mod2 &m2, Mod3 &m3, Mod4 &m4, LastModel &mlast)
create 6 passes
Definition: createpass.hh:458
static SpaceOperatorInterface< typename LastModel ::DestinationType > * create(Mod0 &m0, Mod1 &m1, Mod2 &m2, LastModel &mlast)
create 4 passes
Definition: createpass.hh:418