Exemple #1
0
/* collect global and local iterations info for each time step */
void MRSSKStV::GetIterationInfo(bool get_iters, int loc_iters)
{
	if(get_iters) {
		
		/* write data */
		const StringT& input_file = fSSMatSupport->InputFile();
	
		/* output filenames */
		StringT iterdata;
		iterdata.Root(input_file);
	
		iterdata.Append(".iterdata.", fSSMatSupport->StepNumber());
		
		/* open output streams */
		ofstreamT out_idata(iterdata);

		/* write */
		out_idata << "Time step number:       " << setw(kIntWidth) 
		          << fSSMatSupport->StepNumber() << endl;
		out_idata << "Global iteration number:" << setw(kIntWidth) 
		          << fSSMatSupport->GroupIterationNumber() << endl;
		out_idata << "Number of local iterations to converge:" << setw(kIntWidth) 
		          << loc_iters << endl;
		out_idata.close(); /* close */
		
	} // if(get_iters)
}
Exemple #2
0
/* read initial stress from file */
void MRSSKStV::InitialStress(dSymMatrixT& Stress0)
{
	int ip = CurrIP();
	ElementCardT& element = CurrentElement();
	
	/* read data from file */
	const StringT& input_file = fSSMatSupport->InputFile();
	StringT InitialStressData;
	InitialStressData.Root(input_file);
	// read element by element, ip by ip
	// if data is generated by a program
	Stress0=0.;	
}
Exemple #3
0
/* construct extracting dimensions from the name */
MatrixParameterT::MatrixParameterT(const StringT& name_NxM, char variable):
	ParameterInterfaceT(name_NxM),
	fVariable(variable),
	fCopySymmetric(false)
{
	const char caller[] = "MatrixParameterT::MatrixParameterT";
	const char msg[] = "could not extract %s dimensions from \"%s\" in \"%s\"";

	/* resolve suffix */
	StringT suffix;
	suffix.Suffix(name_NxM, '_');
	if (suffix.StringLength() < 4)
		ExceptionT::GeneralFail(caller, msg, "matrix", suffix.Pointer(), name_NxM.Pointer());
	
	/* resolve column dimensions */
	StringT num;
	num.Suffix(suffix, 'x');
	if (num.StringLength() < 2 || !isdigit(num[1]))
		ExceptionT::GeneralFail(caller, msg, "col", num.Pointer(), name_NxM.Pointer());
	int col = -1;
	col = atoi(num.Pointer(1));
	if (col < 0)
		ExceptionT::GeneralFail(caller, msg, "col", num.Pointer(), name_NxM.Pointer());
	
	/* resolve row dimensions */
	suffix.Root('x');
	if (suffix.StringLength() < 2 || !isdigit(suffix[1]))
		ExceptionT::GeneralFail(caller, msg, "row", suffix.Pointer(), name_NxM.Pointer());
	int row = -1;
	row = atoi(suffix.Pointer(1));
	if (row < 0)
		ExceptionT::GeneralFail(caller, msg, "row", suffix.Pointer(), name_NxM.Pointer());
	
	/* initialize */
	fMatrix.Dimension(row, col);
	fMatrix = 0.0;
}
Exemple #4
0
/* initialization */
void SCNIMFT::TakeParameterList(const ParameterListT& list)
{
  const char caller[] = "SCNIMFT::TakeParameterList";
	
  /* dimension */
  int nsd = NumSD();
	
  /* get parameters needed to construct shape functions */
  fMeshfreeParameters = list.ListChoice(*this, "meshfree_support_choice");
	
  /* access to the model database */
  ModelManagerT& model = ElementSupport().ModelManager();

  /* extract particle ID's */
  const ParameterListT& particle_ID_params = list.GetList("mf_particle_ID_list");
  ArrayT<StringT> particle_ID_list;
  StringListT::Extract(particle_ID_params, particle_ID_list);

  //get nodes from ModelManagerT
  model.ManyNodeSets(particle_ID_list, fNodes);
	
  /** This class and its derived classes assume the list of nodes is sorted */
  fNodes.SortAscending();
		
  /* set inverse map */
  fNodes_inv.SetOutOfRange(InverseMapT::MinusOne);
  fNodes_inv.SetMap(fNodes);
	
  // get the cell geometry parameters
  const ParameterListT* geometry_params = list.ListChoice(*this, "cell_geometry_choice");
  if (geometry_params->Name() == "voronoi_diagram")
    fCellGeometry = new VoronoiDiagramT(ElementSupport(), qIsAxisymmetric);
  else if (geometry_params->Name() == "cell_from_mesh")
    fCellGeometry = new CellFromMeshT(ElementSupport(), qIsAxisymmetric);
  else
    ExceptionT::GeneralFail(caller,"Cannot get valid cell geometry from input file\n");
  fCellGeometry->TakeParameterList(*geometry_params);
  fCellGeometry->SetNodalElements(this);
	
  /* inherited */
  ElementBaseT::TakeParameterList(list);

  /* re-dimension "element" force and stiffness contributions */
  fLHS.Dimension(nsd);
	
  /* allocate work space */
  fForce_man.SetWard(0, fForce, nsd);
  fForce_man.SetMajorDimension(ElementSupport().NumNodes(), false);

  /* write parameters */
  ostream& out = ElementSupport().Output();
	
  /* shape functions */
  /* only support single list of integration cells for now */
  if (fElementConnectivities.Length() > 1) {
    ExceptionT::GeneralFail(caller,"Multiple ElementConnectivities not yet supported\n");
  }

  /* construct shape functions */
  fNodalShapes = new MeshFreeNodalShapeFunctionT(nsd,
						 ElementSupport().InitialCoordinates(), *fElementConnectivities[0], 
						 fNodalCoordinates, *fMeshfreeParameters);
  if (!fNodalShapes) throw ExceptionT::kOutOfMemory;
	
  /* echo parameters */
  fNodalShapes->WriteParameters(ElementSupport().Output());

  /* MLS stuff */
  fNodalShapes->SetSupportSize();

  /* exchange nodal parameters (only Dmax for now) */
  const ArrayT<int>* p_nodes_in = ElementSupport().ExternalNodes();
  if (p_nodes_in) {

    /* skip MLS fit at external nodes */
    iArrayT nodes_in;
    nodes_in.Alias(*p_nodes_in);
    fNodalShapes->SetSkipNodes(nodes_in);
		
    /* exchange */
    CommManagerT& comm = ElementSupport().CommManager();

    /* send all */
    dArray2DT& nodal_params = fNodalShapes->NodalParameters();

    /* initialize the exchange */
    int id = comm.Init_AllGather(nodal_params);
		
    /* do the exchange */
    comm.AllGather(id, nodal_params);
		
    /* clear the communication */
    comm.Clear_AllGather(id);
  }
	
  /* set nodal neighborhoods */
  fNodalShapes->SetNeighborData();
	
  /* final MLS initializations */
  fNodalShapes->WriteStatistics(ElementSupport().Output());
	
  /* initialize workspace for strain smoothing */
  fCellGeometry->SetNodesAndShapes(&fNodes, &fNodalCoordinates, fNodalShapes);
  fCellGeometry->ComputeBMatrices(nodalCellSupports, bVectorArray, fCellVolumes, 
				  fCellCentroids, circumferential_B);

  /* store shape functions at nodes */
  int nNodes = fNodes.Length();
  dArrayT nodalCoords;
  const RaggedArray2DT<int>& nodeSupport = fNodalShapes->NodeNeighbors();
  ArrayT<int> neighbor_list;
  ArrayT< LinkedListT<double> > nodal_phi;
  ArrayT< LinkedListT<int> > nodal_supports;
  nodal_phi.Dimension(nNodes);
  nodal_supports.Dimension(nNodes);
  for (int i = 0; i < nNodes; i++) {
    int node_i = fNodes[i];
    nodalCoords.Alias(nsd, fNodalCoordinates(i));
	
    neighbor_list.Dimension(nodeSupport.MinorDim(node_i));
    neighbor_list.Copy(nodeSupport(node_i));
    if (!fNodalShapes->SetFieldUsing(nodalCoords, neighbor_list)) // shift = 0 or not ?
      ExceptionT::GeneralFail("SCNIMFT::TakeParameterList","Shape Function evaluation"
			      "failed at node %d\n",fNodes[i]);		
		
    nodal_phi[i].AppendArray(fNodalShapes->FieldAt().Length(),
			     const_cast <double *> (fNodalShapes->FieldAt().Pointer()));
    nodal_supports[i].AppendArray(fNodalShapes->Neighbors().Length(),
				  const_cast <int *> (fNodalShapes->Neighbors().Pointer()));
  }
	
  // move into RaggedArray2DT's
  // move into more efficient storage for computation
  fNodalPhi.Configure(nodal_phi);
  fNodalSupports.Configure(nodal_supports);
	
  if (nodal_supports.Length() != nodal_phi.Length())
    ExceptionT::GeneralFail(caller,"nodal support indices and shape function values do not match\n");
		
  for (int i = 0; i < nodal_supports.Length(); i++) {
    int* irow_i = fNodalSupports(i);
    double* drow_i = fNodalPhi(i);
    LinkedListT<int>& ilist = nodal_supports[i];
    LinkedListT<double>& dlist = nodal_phi[i];
    ilist.Top(); dlist.Top();
    while (ilist.Next() && dlist.Next()) {
      *irow_i++ = *(ilist.CurrentValue());
      *drow_i++ = *(dlist.CurrentValue());
    }
  }

  /* output nodal shape function information */
  if (ElementSupport().Logging() == GlobalT::kVerbose)
    {
      /* output file root */
      StringT root;
      root.Root(ElementSupport().InputFile());
      ofstreamT out;

      /* nodal neighbors */
      StringT neighbor_file = root;
      neighbor_file.Append(".", Name(), ".nodal_neighbors");
      out.open(neighbor_file);
      fNodalShapes->MeshFreeSupport().WriteNodalNeighbors(out);
      out.close();

      /* nodal shape functions */
      StringT shape_file = root;
      shape_file.Append(".", Name(), ".nodal_phi");
      out.open(shape_file);
      fNodalShapes->MeshFreeSupport().WriteNodalShapes(out);
      out.close();
    }

  // store shape function information for boundary integration
  fCellGeometry->BoundaryShapeFunctions(fBoundaryPhi, fBoundarySupports, fBoundaryFacetNormals);
	
  /* material Data */
  ParameterListT mat_params;
  CollectMaterialInfo(list, mat_params);
  fMaterialList = NewMaterialList(mat_params.Name(), mat_params.NumLists());
 
  if (!fMaterialList)
    ExceptionT::GeneralFail(caller,"could not construct material list \"%s\"", mat_params.Name().Pointer());
  fMaterialList->TakeParameterList(mat_params);
	
  /* body force */
  const ParameterListT* body_force = list.List("body_force");
  if (body_force) {
    int schedule = body_force->GetParameter("schedule");
    fBodySchedule = ElementSupport().Schedule(--schedule);
    /* body force vector */
    const ArrayT<ParameterListT>& body_force_vector = body_force->Lists();
    if (body_force_vector.Length() != NumDOF())
      ExceptionT::BadInputValue(caller, "body force is length %d not %d",
				body_force_vector.Length(), NumDOF());
    fBody.Dimension(NumDOF());
    for (int i = 0; i < fBody.Length(); i++)
      fBody[i] = body_force_vector[i].GetParameter("value");
  }
	
  /* extract natural boundary conditions */
  TakeNaturalBC(list);

  /* output variables */
  fOutputFlags.Dimension(kNumOutput);
  fOutputFlags = 0;
  const ParameterListT* output = list.List("scni_output");
  if (output) 
    {
      /* set flags */
      for (int i = 0; i < kNumOutput; i++)
	{
	  /* look for entry */
	  const ParameterT* value = output->Parameter(OutputNames[i]);
	  if (value) {
	    int do_write = *value;
	    if (do_write)
	      fOutputFlags[i] = 1;
	  }
	}
    }
}
Exemple #5
0
/* accept parameter list */
void CSEBaseT::TakeParameterList(const ParameterListT& list)
{
	const char caller[] = "CSEBaseT::TakeParameterList";

	/* axisymmetry */
	fAxisymmetric = list.GetParameter("axisymmetric");
	if (fAxisymmetric && NumSD() != 2) /* check */
		ExceptionT::GeneralFail(caller, "expecting 2 dimensions not %d with axisymmetry", NumSD());

	/* element geometry - need to set geometry before calling inherited method */
	const ParameterListT& geom = list.GetListChoice(*this, "surface_geometry");
	fGeometryCode = GeometryT::string2CodeT(geom.Name());
	fNumIntPts = geom.GetParameter("num_ip");

	/* inherited */
	ElementBaseT::TakeParameterList(list);

	/* take parameters */
	fCloseSurfaces = list.GetParameter("close_surfaces");
	fOutputArea = list.GetParameter("output_area");

	/* pre-crack */
	const ParameterListT* pre_crack = list.List("pre_crack");
	if (pre_crack) {
		fpc_AndOr = int2AndOrT(pre_crack->GetParameter("and_or"));
		int num_rules = pre_crack->NumLists("pre_crack_rule");
		fpc_coordinate.Dimension(num_rules);
		fpc_op.Dimension(num_rules);
		fpc_value.Dimension(num_rules);
		for (int i = 0; i < num_rules; i++) {
			const ParameterListT& pre_crack_rule = pre_crack->GetList("pre_crack_rule", i);
			fpc_coordinate[i] = int2CoordinateT(pre_crack_rule.GetParameter("coordinate"));
			fpc_op[i] = int2OpT(pre_crack_rule.GetParameter("op"));
			fpc_value[i] = pre_crack_rule.GetParameter("value");
		}
	}

	/* nodal output codes */
	fNodalOutputCodes.Dimension(NumNodalOutputCodes);
	fNodalOutputCodes = 0;
	const ParameterListT* nodal_output = list.List("surface_element_nodal_output");
	if (nodal_output)
		for (int i = 0; i < NumNodalOutputCodes; i++)
		{
			/* look for entry */
			const ParameterT* nodal_value = nodal_output->Parameter(NodalOutputNames[i]);
			if (nodal_value) {
				int do_write = *nodal_value;
				if (do_write == 1)
					fNodalOutputCodes[i] = 1;
				else if (i == NodalTraction && do_write == 2) {
					fNodalOutputCodes[i] = 1;
					fOutputGlobalTractions = true;
				}
			}
		}

	/* element output codes */
	fElementOutputCodes.Dimension(NumElementOutputCodes);
	fElementOutputCodes = 0;
	const ParameterListT* element_output = list.List("surface_element_element_output");
	if (element_output)
		for (int i = 0; i < NumElementOutputCodes; i++)
		{
			/* look for entry */
			const ParameterT* element_value = element_output->Parameter(ElementOutputNames[i]);
			if (element_value) {
				int do_write = *element_value;
				if (do_write == 1)
					fElementOutputCodes[i] = 1;
			}
		}

	/* dimensions */
	int num_facet_nodes = NumFacetNodes();

	/* initialize local arrays */
	fLocInitCoords1.Dimension(num_facet_nodes, NumSD());
	fLocCurrCoords.Dimension(NumElementNodes(), NumSD());
	ElementSupport().RegisterCoordinates(fLocInitCoords1);
	ElementSupport().RegisterCoordinates(fLocCurrCoords);

	/* construct surface shape functions */
	fShapes = new SurfaceShapeT(fGeometryCode, fNumIntPts, NumElementNodes(), 
		num_facet_nodes, NumDOF(), fLocInitCoords1);
	if (!fShapes) throw ExceptionT::kOutOfMemory;
	fShapes->Initialize();

	/* work space */
	fNodes1.Dimension(num_facet_nodes);
	int nee = NumElementNodes()*NumDOF();
	fNEEvec.Dimension(nee);
	fNEEmat.Dimension(nee);

	/* close surfaces */
	if (fCloseSurfaces) CloseSurfaces();

#ifndef _FRACTURE_INTERFACE_LIBRARY_
	/* output stream */
	if (fOutputArea == 1)
	{
		/* generate file name */
		StringT name = ElementSupport().InputFile();
		name.Root();
		name.Append(".grp", ElementSupport().ElementGroupNumber(this) + 1);
		name.Append(".fracture");
		
		/* open stream */
		farea_out.open(name);
	}
#endif
}
Exemple #6
0
void ContactElementT::WriteOutput(void)
{
ExceptionT::GeneralFail("ContactElementT::WriteOutput", "out of date");
#if 0
// look at EXODUS output in continuumelementT
	/* contact statistics */
	ostream& out = ElementSupport().Output();
	out << "\n Contact tracking: group "
                << ElementSupport().ElementGroupNumber(this) + 1 << '\n';
	out << " Time                           = "
                << ElementSupport().Time() << '\n';
	if (fNumOutputVariables) {
		for(int s = 0; s < fSurfaces.Length(); s++) {
			const ContactSurfaceT& surface = fSurfaces[s];
			dArray2DT n_values(surface.GlobalNodeNumbers().Length(), 
							fNumOutputVariables);
			n_values = 0.0;
			surface.CollectOutput(fOutputFlags,n_values);
			dArray2DT e_values;
			/* send to output */
			ElementSupport().WriteOutput(fOutputID[s], n_values, e_values);
		}
	}

	/* output files */
	StringT filename;
	filename.Root(ElementSupport().Input().filename());
	filename.Append(".", ElementSupport().StepNumber());
	filename.Append("of", ElementSupport().NumberOfSteps());

	for(int s = 0; s < fSurfaces.Length(); s++) {
		const ContactSurfaceT& surface = fSurfaces[s];

#if TEXT_OUTPUT
		if (fOutputFlags[kGaps]) {
                StringT gap_out;
                gap_out = gap_out.Append(filename,".gap");
                gap_out = gap_out.Append(s);
                ofstream gap_file (gap_out);
                surface.PrintGaps(gap_file);


		}
		if (fOutputFlags[kMultipliers]) {
//		surface.PrintMultipliers(cout);
                StringT pressure_out;
                pressure_out = pressure_out.Append(filename,".pre");
                pressure_out = pressure_out.Append(s);
                ofstream pressure_file (pressure_out);
                surface.PrintMultipliers(pressure_file);
		}

		if (fOutputFlags[kNormals]) {
                StringT normal_out;
                normal_out = normal_out.Append(filename,".normal");
                normal_out = normal_out.Append(s);
                ofstream normal_file (normal_out);
                surface.PrintNormals(normal_file);
		}
#endif

		if (fOutputFlags[kMultipliers]) { surface.PrintMultipliers(cout);}
		if (fOutputFlags[kStatus]) { surface.PrintStatus(cout); }
		if (fOutputFlags[kArea]) { surface.PrintContactArea(cout); }
	}
#endif
}