dune-fem  2.4.1-rc
createpass.hh
Go to the documentation of this file.
1 #ifndef DUNE_FEM_CREATEPASS_HH
2 #define DUNE_FEM_CREATEPASS_HH
3 
6 
7 namespace Dune
8 {
9 
10  namespace Fem
11  {
12 
34  template< class Model , template <class,class,int> class PassType , int pId = -1 >
35  class CreatePass
36  {
37  public:
39  enum { passId = pId };
40 
42  typedef typename Model :: Traits :: DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
44  typedef typename Model :: Traits :: DiscreteFunctionType DestinationType;
45 
48  protected:
49  Model& model_;
50  const DiscreteFunctionSpaceType& space_;
51  SpaceOperatorIFType* passPointer_;
52 
53  public:
57  CreatePass(Model& model, const DiscreteFunctionSpaceType& space)
58  : model_(model) , space_(space) , passPointer_(0)
59  {
60  }
61 
65  CreatePass(const Model& model, const DiscreteFunctionSpaceType& space)
66  : model_(const_cast<Model&> (model)) , space_(space) , passPointer_(0)
67  {
68  }
69 
71  CreatePass(const CreatePass& org)
72  : model_(org.model_),
73  space_(org.space_),
74  passPointer_( org.passPointer_ )
75  {
76  }
77 
79  template <class PreviousPass>
82  {
83  typedef PassType< Model , PreviousPass , passId > RealPassType;
84  typedef SpaceOperatorPtr<RealPassType> ObjPtrType;
85  // create pass
86  RealPassType* pass = new RealPassType(model_,prevObj->pass(),space_);
87 
88  // create pass storage
89  ObjPtrType* obj = new ObjPtrType(pass);
90 
91  // remember pass obj
92  passPointer_ = obj;
93 
94  // remember previous object for delete
95  obj->saveObjPointer(prevObj);
96  return obj;
97  }
98 
100  template <class PreviousPass>
103  {
104  typedef PassType< Model , PreviousPass , passId > RealPassType;
105  typedef SpaceOperatorWrapper<RealPassType> ObjPtrType;
106  // create pass
107  RealPassType* pass = new RealPassType(model_,prevObj->pass(),space_);
108 
109  // create pass storage
110  ObjPtrType* obj = new ObjPtrType(pass);
111 
112  // remember pass obj
113  passPointer_ = obj;
114 
115  // remember previous object for delete
116  obj->saveObjPointer(prevObj);
117  return obj;
118  }
119 
121  SpaceOperatorIFType* pass()
122  {
123  assert( passPointer_ );
124  return passPointer_;
125  }
126 
128  const DestinationType* destination() const
129  {
130  assert( passPointer_ );
131  return passPointer_->destination();
132  }
133  };
134 
135 
137  template <class DiscreteModelImp, class SelectorImp>
139  : public ObjPointerStorage,
140  public DiscreteModelImp
141  {
142  // type of base class
143  typedef DiscreteModelImp BaseType;
144  public:
146  typedef SelectorImp SelectorType;
148  DiscreteModelWrapper(const BaseType& base)
149  : BaseType(base) // calling copy constructor of base
150  {}
151 
154  : BaseType(other) // calling copy constructor of base
155  {}
156  };
157 
159  template <class Model, class SelectorImp, template <class,class> class PassType>
161  {
162  public:
164  typedef typename Model :: Traits :: DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
166  typedef typename Model :: Traits :: DiscreteFunctionType DestinationType;
167 
170 
173  protected:
174  DiscreteModelType* model_;
175  const DiscreteFunctionSpaceType& space_;
176  SpaceOperatorIFType* passPointer_;
177  bool owner_;
178 
179  public:
183  CreateSelectedPass(Model& model, const DiscreteFunctionSpaceType& space)
184  : model_(new DiscreteModelType(model))
185  , space_(space)
186  , passPointer_(0)
187  , owner_(true)
188  {
189  }
190 
193  : model_(new DiscreteModelType(org.model_)),
194  space_(org.space_),
195  passPointer_( org.passPointer_ ),
196  owner_(true)
197  {
198  }
199 
202  {
203  if( owner_ ) delete model_;
204  model_ = 0;
205  }
206 
208  template <class PreviousPass>
211  {
212  typedef PassType<DiscreteModelType,PreviousPass> RealPassType;
213  typedef SpaceOperatorPtr<RealPassType> ObjPtrType;
214  // create pass
215  RealPassType* pass = new RealPassType(*model_,prevObj->pass(),space_);
216 
217  // create pass storage
218  ObjPtrType* obj = new ObjPtrType(pass, model_ );
219 
220  // don't delete model anymore
221  owner_ = false;
222 
223  // remember pass obj
224  passPointer_ = obj;
225 
226  // remember previous object for delete
227  obj->saveObjPointer(prevObj);
228  return obj;
229  }
230 
232  template <class PreviousPass>
235  {
236  typedef PassType<DiscreteModelType,PreviousPass> RealPassType;
237  typedef SpaceOperatorWrapper<RealPassType> ObjPtrType;
238  // create pass
239  RealPassType* pass = new RealPassType(*model_,prevObj->pass(),space_);
240 
241  // create pass storage
242  ObjPtrType* obj = new ObjPtrType(pass, model_);
243 
244  // don't delete model anymore
245  owner_ = false;
246 
247  // remember pass obj
248  passPointer_ = obj;
249 
250  // remember previous object for delete
251  obj->saveObjPointer(prevObj);
252  return obj;
253  }
254 
256  SpaceOperatorIFType* pass()
257  {
258  assert( passPointer_ );
259  return passPointer_;
260  }
261 
263  const DestinationType* destination() const
264  {
265  assert( passPointer_ );
266  return passPointer_->destination();
267  }
268  };
269 
275  template <class Model, template <class,class,int> class PassType,
276  class SpaceType, // = typename Model :: Traits :: DiscreteFunctionSpaceType ,
277  int pId
278  >
280  {
281  public:
283  enum { passId = pId };
284 
286  typedef SpaceType DiscreteFunctionSpaceType;
288  typedef typename Model :: Traits :: DiscreteFunctionType DestinationType;
289 
292  protected:
293  Model& model_;
294  DiscreteFunctionSpaceType& space_;
295  const std::string paramFile_;
296  SpaceOperatorIFType* passPointer_;
297 
298  public:
303  CreateFeaturedPass(Model& model, DiscreteFunctionSpaceType& space, std::string paramfile = "")
304  : model_(model),
305  space_(space),
306  paramFile_(paramfile),
307  passPointer_(0)
308  {
309  }
310 
313  : model_(org.model_) , space_(org.space_),
314  paramFile_(org.paramFile_),
315  passPointer_(org.passPointer_)
316  {
317  }
318 
320  template <class PreviousPass>
323  {
324  typedef PassType<Model,PreviousPass,passId> RealPassType;
325  typedef SpaceOperatorPtr<RealPassType> ObjPtrType;
326  // create pass
327  RealPassType* pass = new RealPassType(model_,prevObj->pass(),space_,paramFile_);
328 
329  // create pass storage
330  ObjPtrType* obj = new ObjPtrType(pass);
331 
332  // remember pass obj
333  passPointer_ = obj;
334 
335  // remember previous object for delete
336  obj->saveObjPointer(prevObj);
337  return obj;
338  }
339 
341  template <class PreviousPass>
344  {
345  typedef PassType<Model,PreviousPass,passId> RealPassType;
346  typedef SpaceOperatorWrapper<RealPassType> ObjPtrType;
347  // create pass
348  RealPassType* pass = new RealPassType(model_,prevObj->pass(),space_,paramFile_);
349 
350  // create pass storage
351  ObjPtrType* obj = new ObjPtrType(pass);
352 
353  // remember pass obj
354  passPointer_ = obj;
355 
356  // remember previous object for delete
357  obj->saveObjPointer(prevObj);
358  return obj;
359  }
360 
362  const DestinationType* destination() const
363  {
364  assert( passPointer_ );
365  return passPointer_->destination();
366  }
367  };
368 
373  template <int startPassId = -1>
375  {
376  protected:
378  template <class DestinationType>
380  {
381  typedef StartPass<DestinationType, startPassId> StartPassType;
382  typedef SpaceOperatorStorage<StartPassType> ObjPtrType;
383 
384  // create start pass
385  StartPassType* startPass = new StartPassType ();
386 
387  // create pass storage
388  ObjPtrType* obj = new ObjPtrType(startPass);
389 
390  // return obj
391  return obj;
392  }
393 
394  public:
396  template <class LastModel>
398  create(LastModel& ml)
399  {
400  return ml.createLast( createStartPass<typename LastModel :: DestinationType> () );
401  }
402 
404  template <class FirstModel,
405  class LastModel>
407  create(FirstModel& mf,
408  LastModel& ml)
409  {
410  return ml.createLast( mf.create( createStartPass<typename LastModel :: DestinationType>() ) );
411  }
412 
414  template <class Mod0,
415  class Mod1,
416  class LastModel>
418  create(Mod0& m0,
419  Mod1& m1,
420  LastModel& mlast)
421  {
422  return mlast.createLast(
423  m1.create(
424  m0.create( createStartPass<typename LastModel :: DestinationType> () )
425  )
426  );
427  }
428 
430  template <class Mod0,
431  class Mod1,
432  class Mod2,
433  class LastModel>
435  create(Mod0& m0,
436  Mod1& m1,
437  Mod2& m2,
438  LastModel& mlast)
439  {
440  return mlast.createLast( m2.create( m1.create(
441  m0.create( createStartPass<typename LastModel :: DestinationType> () )
442  ) ) );
443  }
444 
446  template <class Mod0,
447  class Mod1,
448  class Mod2,
449  class Mod3,
450  class LastModel>
452  create(Mod0& m0,
453  Mod1& m1,
454  Mod2& m2,
455  Mod3& m3,
456  LastModel& mlast)
457  {
458  return
459  mlast.createLast(
460  m3.create(
461  m2.create(
462  m1.create(
463  m0.create( createStartPass<typename LastModel :: DestinationType> () )
464  ))));
465  }
466 
468  template <class Mod0,
469  class Mod1,
470  class Mod2,
471  class Mod3,
472  class Mod4,
473  class LastModel>
475  create(Mod0& m0,
476  Mod1& m1,
477  Mod2& m2,
478  Mod3& m3,
479  Mod4& m4,
480  LastModel& mlast)
481  {
482  return
483  mlast.createLast(
484  m4.create(
485  m3.create(
486  m2.create(
487  m1.create(
488  m0.create( createStartPass<typename LastModel :: DestinationType> () )
489  )))) );
490  }
492  template <class Mod0,
493  class Mod1,
494  class Mod2,
495  class Mod3,
496  class Mod4,
497  class Mod5,
498  class LastModel>
500  create(Mod0& m0,
501  Mod1& m1,
502  Mod2& m2,
503  Mod3& m3,
504  Mod4& m4,
505  Mod5& m5,
506  LastModel& mlast)
507  {
508  return
509  mlast.createLast(
510  m5.create(
511  m4.create(
512  m3.create(
513  m2.create(
514  m1.create(
515  m0.create( createStartPass<typename LastModel :: DestinationType> () )
516  )))) ));
517  }
518 
520  template <class Mod0,
521  class Mod1,
522  class Mod2,
523  class Mod3,
524  class Mod4,
525  class Mod5,
526  class Mod6,
527  class LastModel>
529  create(Mod0& m0,
530  Mod1& m1,
531  Mod2& m2,
532  Mod3& m3,
533  Mod4& m4,
534  Mod5& m5,
535  Mod6& m6,
536  LastModel& mlast)
537  {
538  return
539  mlast.createLast(
540  m6.create(
541  m5.create(
542  m4.create(
543  m3.create(
544  m2.create(
545  m1.create(
546  m0.create( createStartPass<typename LastModel :: DestinationType> () )
547  )))) )));
548  }
550  template <class Mod0,
551  class Mod1,
552  class Mod2,
553  class Mod3,
554  class Mod4,
555  class Mod5,
556  class Mod6,
557  class Mod7,
558  class LastModel>
560  create(Mod0& m0,
561  Mod1& m1,
562  Mod2& m2,
563  Mod3& m3,
564  Mod4& m4,
565  Mod5& m5,
566  Mod6& m6,
567  Mod7& m7,
568  LastModel& mlast)
569  {
570  return
571  mlast.createLast(
572  m7.create(
573  m6.create(
574  m5.create(
575  m4.create(
576  m3.create(
577  m2.create(
578  m1.create(
579  m0.create( createStartPass<typename LastModel :: DestinationType> () )
580  )))) ))));
581  }
582  };
583 
584  } // namespace Fem
585 
586 } // namespace Dune
587 #endif // #ifndef DUNE_FEM_CREATEPASS_HH
DiscreteModelWrapper(const DiscreteModelWrapper &other)
copy constructor
Definition: createpass.hh:153
DiscreteFunctionSpaceType & space_
Definition: createpass.hh:294
Model & model_
Definition: createpass.hh:49
Model::Traits::DiscreteFunctionType DestinationType
destination type
Definition: createpass.hh:44
Definition: createpass.hh:39
const std::string paramFile_
Definition: createpass.hh:295
SpaceOperatorWrapper< PassType< Model, PreviousPass, passId > > * createLast(SpaceOperatorStorage< PreviousPass > *prevObj)
last creation method
Definition: createpass.hh:102
const DiscreteFunctionSpaceType & space_
Definition: createpass.hh:175
create pass tree from given list of discrete models the passId is deliviered to the start pass and st...
Definition: createpass.hh:374
apply wrapper
Definition: spaceoperatorif.hh:317
Model::Traits::DiscreteFunctionType DestinationType
destination type
Definition: createpass.hh:166
only for keeping the pointer
Definition: spaceoperatorif.hh:254
SpaceOperatorPtr< PassType< DiscreteModelType, PreviousPass > > * create(SpaceOperatorStorage< PreviousPass > *prevObj)
creation method
Definition: createpass.hh:210
const DestinationType * destination() const
return pointer to destination
Definition: createpass.hh:263
const DestinationType * destination() const
return pointer to destination
Definition: createpass.hh:362
virtual const DestinationType * destination() const
return reference to pass&#39;s local memory
Definition: spaceoperatorif.hh:207
CreatePass takes a discrete model and a PassType (like LocalDGPass) and creates with the parameter Pr...
Definition: createpass.hh:35
CreateSelectedPass(const CreateSelectedPass &org)
copy constructor
Definition: createpass.hh:192
DiscreteModelWrapper to combine DiscreteModel and Selector.
Definition: createpass.hh:138
bool owner_
Definition: createpass.hh:177
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:560
SpaceOperatorInterface< DestinationType > SpaceOperatorIFType
type of space operator
Definition: createpass.hh:47
CreateSelectedPass(Model &model, const DiscreteFunctionSpaceType &space)
Definition: createpass.hh:183
CreateFeaturedPass(const CreateFeaturedPass &org)
copy constructor
Definition: createpass.hh:312
DiscreteModelType * model_
Definition: createpass.hh:174
SpaceOperatorIFType * pass()
return pointer to space operator if
Definition: createpass.hh:256
OperatorType & pass() const
return reference to pass
Definition: spaceoperatorif.hh:245
CreatePass(const CreatePass &org)
copy constructor
Definition: createpass.hh:71
SpaceType DiscreteFunctionSpaceType
type of discrete functions space
Definition: createpass.hh:286
SpaceOperatorIFType * passPointer_
Definition: createpass.hh:51
CreatePass(const Model &model, const DiscreteFunctionSpaceType &space)
Definition: createpass.hh:65
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:500
Definition: objpointer.hh:37
SpaceOperatorWrapper< PassType< DiscreteModelType, PreviousPass > > * createLast(SpaceOperatorStorage< PreviousPass > *prevObj)
last creation method
Definition: createpass.hh:234
Model & model_
Definition: createpass.hh:293
Model::Traits::DiscreteFunctionSpaceType DiscreteFunctionSpaceType
type of discrete function space
Definition: createpass.hh:164
interface for time evolution operators
Definition: spaceoperatorif.hh:101
SpaceOperatorIFType * passPointer_
Definition: createpass.hh:176
CreateFeaturedPass(Model &model, DiscreteFunctionSpaceType &space, std::string paramfile="")
Definition: createpass.hh:303
SpaceOperatorInterface< DestinationType > SpaceOperatorIFType
type of space operator
Definition: createpass.hh:169
Definition: coordinate.hh:4
Model::Traits::DiscreteFunctionSpaceType DiscreteFunctionSpaceType
type of discrete function space
Definition: createpass.hh:42
Model::Traits::DiscreteFunctionType DestinationType
destination type
Definition: createpass.hh:288
static SpaceOperatorStorage< StartPass< DestinationType, startPassId > > * createStartPass()
method that creates first pass
Definition: createpass.hh:379
const DestinationType * destination() const
return pointer to destination
Definition: createpass.hh:128
CreateFeaturedPass takes a discrete model and a PassType (like LocalDGEllliptPass) and creates with t...
Definition: createpass.hh:279
const DiscreteFunctionSpaceType & space_
Definition: createpass.hh:50
SpaceOperatorPtr< PassType< Model, PreviousPass, passId > > * create(SpaceOperatorStorage< PreviousPass > *prevObj)
creation method
Definition: createpass.hh:322
create pass with previous unknown selector
Definition: createpass.hh:160
static SpaceOperatorInterface< typename LastModel::DestinationType > * create(FirstModel &mf, LastModel &ml)
create 2 passes
Definition: createpass.hh:407
SpaceOperatorIFType * passPointer_
Definition: createpass.hh:296
DiscreteModelWrapper(const BaseType &base)
constructor calling the copy constructor of the base type
Definition: createpass.hh:148
static SpaceOperatorInterface< typename LastModel::DestinationType > * create(Mod0 &m0, Mod1 &m1, LastModel &mlast)
create 3 passes
Definition: createpass.hh:418
SpaceOperatorIFType * pass()
return pointer to space operator if
Definition: createpass.hh:121
static SpaceOperatorInterface< typename LastModel::DestinationType > * create(LastModel &ml)
create 1 pass
Definition: createpass.hh:398
DiscreteModelWrapper< Model, SelectorImp > DiscreteModelType
type of discrete model
Definition: createpass.hh:172
static SpaceOperatorInterface< typename LastModel::DestinationType > * create(Mod0 &m0, Mod1 &m1, Mod2 &m2, LastModel &mlast)
create 4 passes
Definition: createpass.hh:435
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:529
only for keeping the pointer
Definition: spaceoperatorif.hh:212
~CreateSelectedPass()
destructor deleting model if still owner
Definition: createpass.hh:201
SelectorImp SelectorType
exporting given type of selector
Definition: createpass.hh:146
End marker for a compile-time list of passes.
Definition: common/pass.hh:47
static SpaceOperatorInterface< typename LastModel::DestinationType > * create(Mod0 &m0, Mod1 &m1, Mod2 &m2, Mod3 &m3, Mod4 &m4, LastModel &mlast)
create 6 passes
Definition: createpass.hh:475
SpaceOperatorWrapper< PassType< Model, PreviousPass, passId > > * createLast(SpaceOperatorStorage< PreviousPass > *prevObj)
last creation method
Definition: createpass.hh:343
SpaceOperatorInterface< DestinationType > SpaceOperatorIFType
type of space operator
Definition: createpass.hh:291
CreatePass(Model &model, const DiscreteFunctionSpaceType &space)
Definition: createpass.hh:57
SpaceOperatorPtr< PassType< Model, PreviousPass, passId > > * create(SpaceOperatorStorage< PreviousPass > *prevObj)
creation method
Definition: createpass.hh:81
static SpaceOperatorInterface< typename LastModel::DestinationType > * create(Mod0 &m0, Mod1 &m1, Mod2 &m2, Mod3 &m3, LastModel &mlast)
create 5 passes
Definition: createpass.hh:452