Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members   Related Pages  

grid_construction/GridConstructionX.C.sed

Go to the documentation of this file.
00001 /*
00002   Id:           $Id: GridConstructionX.C.sed,v 1.1.2.2 2002/03/20 00:43:45 gunney Exp $
00003   Copyright:    (c) 1997-2000 The Regents of the University of California
00004   Release:      $Name: v_0_1_7 $
00005   Revision:     $Revision: 1.1.2.2 $
00006   Modified:     $Date: 2002/03/20 00:43:45 $
00007   Description:  GridConstructionX class implementation
00008 */
00009 
00010 
00011 #include <setArrayData.h>
00012 #include <MultiDimArrayAccess.h>
00013 #include <arrayConversionX.h>
00014 #include <printObjectX.h>
00015 #include "GridConstructionX.h"
00016 
00017 #include <hier_Variable2.h>
00018 #define hier_VariableX SAMRAI::hier_Variable2
00019 #include <hier_VariableDatabase2.h>
00020 #define hier_VariableDatabaseX SAMRAI::hier_VariableDatabase2
00021 #include <pdat_CellData2.h>
00022 #define pdat_CellDataX SAMRAI::pdat_CellData2
00023 #include <hier_Patch2.h>
00024 #define hier_PatchX SAMRAI::hier_Patch2
00025 #include <geom_CartesianPatchGeometry2.h>
00026 #define geom_CartesianPatchGeometryX SAMRAI::geom_CartesianPatchGeometry2
00027 
00028 
00029 
00030 
00031 GridConstructionX::GridConstructionX(
00032   const string &object_name
00033 , tbox_Pointer<tbox_Database> database
00034 )
00035 : d_context_all("ALL")
00036 , d_constitutive("solution:constitutive",2)
00037 , d_scalar("solution:scalar",1)
00038 , d_vector("solution:vector",3)
00039 {
00040 
00041   /*
00042     Register variables with VariableDatabase and get the descriptor indices
00043     for those variables.
00044   */
00045   {
00046     tbox_Pointer<hier_VariableContext> context_all_ptr(&d_context_all,false);
00047     hier_VariableDatabaseX *variable_db = hier_VariableDatabaseX::getDatabase();
00048     {
00049       int constitutive_id, scalar_id, vector_id;
00050       /*
00051         registerVariableAndContext returns the index unique to the
00052         vector-context pair.  It is not necessary to save it, because
00053         it can always be retrieved by  a call to
00054         variable_db->mapVariableAndContextToIndex.
00055         We just save it here to emphasize that it can be done.
00056       */
00057       constitutive_id
00058         = variable_db->registerVariableAndContext(
00059           tbox_Pointer<hier_VariableX>(&d_constitutive,false)
00060           , context_all_ptr );
00061       scalar_id
00062         = variable_db->registerVariableAndContext(
00063           tbox_Pointer<hier_VariableX>(&d_scalar,false)
00064           , context_all_ptr );
00065       vector_id
00066         = variable_db->registerVariableAndContext(
00067           tbox_Pointer<hier_VariableX>(&d_vector,false)
00068           , context_all_ptr );
00069     }
00070   }
00071 
00072   return;
00073 }
00074 
00075 
00076 
00077 
00078 
00079 
00080 
00081 void GridConstructionX::initializeLevelData (
00083     const tbox_Pointer< hier_PatchHierarchyX > hierarchy
00084   , 
00085     const int level_number
00086   , const double init_data_time
00087   , const bool can_be_refined
00088   , 
00089     const bool initial_time
00090   , 
00091     const tbox_Pointer< hier_PatchLevelX > old_level
00092   , const bool allocate_data
00093   ) {
00094 
00095   /*
00096     Reference the level object with the given index from the hierarchy.
00097   */
00098   tbox_Pointer<hier_PatchLevelX> level
00099     = hierarchy->getPatchLevel(level_number);
00100 
00101   /*
00102     Get the index for the data.
00103   */
00104   int constitutive_id, scalar_id, vector_id;
00105   {
00106     hier_VariableDatabaseX *variable_db = hier_VariableDatabaseX::getDatabase();
00107     tbox_Pointer<hier_VariableContext> context_all_ptr(&d_context_all,false);
00108     constitutive_id =
00109       variable_db->mapVariableAndContextToIndex(
00110           tbox_Pointer<pdat_CellVariableX<double> >(&d_constitutive,false)
00111         , context_all_ptr );
00112     scalar_id =
00113       variable_db->mapVariableAndContextToIndex(
00114           tbox_Pointer<pdat_CellVariableX<double> >(&d_scalar,false)
00115         , context_all_ptr );
00116     vector_id =
00117       variable_db->mapVariableAndContextToIndex(
00118           tbox_Pointer<pdat_CellVariableX<double> >(&d_vector,false)
00119         , context_all_ptr );
00120   }
00121 
00122   /*
00123     If instructed, allocate all patch data on the level.
00124   */
00125   if ( allocate_data ) {
00126     level->allocatePatchData( constitutive_id );
00127     level->allocatePatchData( scalar_id );
00128     level->allocatePatchData( vector_id );
00129   }
00130 
00131   /*
00132     Initialize data in all patches in the level.
00133   */
00134   int npatch = level->getNumberOfPatches();
00135   for ( int j=0; j<npatch; j++ ) {
00136     tbox_Pointer<hier_PatchX> patch
00137       = level->getPatch(j);
00138     tbox_Pointer<geom_CartesianPatchGeometryX> patch_geom
00139       = patch->getPatchGeometry();
00140     tbox_Pointer<pdat_CellDataX<double> > constitutive_data
00141       = patch->getPatchData(constitutive_id);
00142     tbox_Pointer<pdat_CellDataX<double> > scalar_data
00143       = patch->getPatchData(scalar_id);
00144     tbox_Pointer<pdat_CellDataX<double> > vector_data
00145       = patch->getPatchData(vector_id);
00146     MultiDimArrayAccess<double,2> t0
00147       = arrayData2ArrayAccess( constitutive_data->getArrayData() , 0 );
00148     setArrayDataToConstant(
00149         t0
00150       , constitutive_data->getGhostBox().lower()
00151       , constitutive_data->getGhostBox().upper()
00152       , patch_geom->getXLower()
00153       , patch_geom->getXUpper()
00154       , patch_geom->getDx()
00155       , double(level_number)
00156       );
00157     MultiDimArrayAccess<double,2> t1
00158       = arrayData2ArrayAccess( constitutive_data->getArrayData() , 1 );
00159     setArrayDataToConstant(
00160         t1
00161       , constitutive_data->getGhostBox().lower()
00162       , constitutive_data->getGhostBox().upper()
00163       , patch_geom->getXLower()
00164       , patch_geom->getXUpper()
00165       , patch_geom->getDx()
00166       , double(level_number)
00167       );
00168     MultiDimArrayAccess<double,2> t2
00169       = arrayData2ArrayAccess( scalar_data->getArrayData() , 0 );
00170     setArrayDataToSinusoidal(
00171         t2 // arrayData2ArrayAccess( scalar_data->getArrayData() , 0 )
00172       , scalar_data->getGhostBox().lower()
00173       , scalar_data->getGhostBox().upper()
00174       , patch_geom->getXLower()
00175       , patch_geom->getXUpper()
00176       , patch_geom->getDx()
00177       );
00178     setArrayDataToSinusoidalGradient(
00179         vector_data->getPointer(0)
00180       , vector_data->getPointer(1)
00181       , scalar_data->getGhostBox().lower()
00182       , scalar_data->getGhostBox().upper()
00183       , patch_geom->getXLower()
00184       , patch_geom->getXUpper()
00185       , patch_geom->getDx()
00186       );
00187     constitutive_data->getArrayData().getPointer(0);
00188     assert( constitutive_data->getArrayData().getPointer(0) );
00189     vector_data->getArrayData().getPointer(0);
00190     assert( vector_data->getArrayData().getPointer(0) );
00191     scalar_data->getArrayData().getPointer(0);
00192     assert( scalar_data->getArrayData().getPointer(0) );
00193   }
00194 }
00195 
00196 
00197 
00198 
00199 int GridConstructionX::registerVariablesWithPlotter(
00200   tbox_Pointer<plot_CartesianVizamraiDataWriterX> viz_writer
00201 ) {
00202 
00203   /*
00204     Get the indices for the data.
00205   */
00206   int constitutive_id, scalar_id, vector_id;
00207   {
00208     hier_VariableDatabaseX *variable_db = hier_VariableDatabaseX::getDatabase();
00209     tbox_Pointer<hier_VariableContext> context_all_ptr(&d_context_all,false);
00210     constitutive_id =
00211       variable_db->mapVariableAndContextToIndex(
00212           tbox_Pointer<pdat_CellVariableX<double> >(&d_constitutive,false)
00213         , context_all_ptr );
00214     scalar_id =
00215       variable_db->mapVariableAndContextToIndex(
00216           tbox_Pointer<pdat_CellVariableX<double> >(&d_scalar,false)
00217         , context_all_ptr );
00218     vector_id =
00219       variable_db->mapVariableAndContextToIndex(
00220           tbox_Pointer<pdat_CellVariableX<double> >(&d_vector,false)
00221         , context_all_ptr );
00222   }
00223 
00224   /*
00225     Register variables with plotter.
00226   */
00227   viz_writer->registerPlotVariable("Constitutive variables", constitutive_id);
00228   viz_writer->registerPlotVariable("A scalar variable", scalar_id);
00229   viz_writer->registerPlotVariable("A vector variable", vector_id);
00230 
00231   return 0;
00232 }

Generated on Wed Apr 17 12:51:44 2002 for samtut by doxygen1.2.12 written by Dimitri van Heesch, © 1997-2001