Beispiel #1
0
/* Batch file processing */
void ExecutionManagerT::RunBatch(ifstreamT& in, ostream& status)
{
	/* mark status */
	status << "\n Processing batch file: " << in.filename() << '\n';
	
	/* start day/date info */
	time_t starttime;
	time(&starttime);

	/* get 1st entry */
	StringT nextinfilename;
	in >> nextinfilename;
	
	/* repeat to end of file */
	while (in.good())
	{
		/* adjusting execution options */
		if (nextinfilename[0] == '-')
			AddCommandLineOption(nextinfilename);
		else /* execute regular file */
		{	
			/* file path format */
			nextinfilename.ToNativePathName();

			/* path to source file */
			StringT path;
			path.FilePath(in.filename());
	
			/* open new input stream */
			nextinfilename.Prepend(path);
			ifstreamT nextin('#', nextinfilename);
	
			/* process if valid */
			if (nextin.is_open())
				JobOrBatch(nextin, cout);
			else
				cout << " File not found: " << nextinfilename << '\n';
		}
			
		/* get next entry */
		in >> nextinfilename;
	}

	/* stop day/date info */
	time_t stoptime;
	time(&stoptime);
	cout << "\n Batch start time  : " << ctime(&starttime);
	cout <<   " Batch stop time   : " << ctime(&stoptime);
}
Beispiel #2
0
EVPFDBaseT::EVPFDBaseT(ifstreamT& in, const FSMatSupportT& support) :
	ParameterInterfaceT("EVPFDBase"),
//  FDHookeanMatT(in, support),
  IsotropicT  (in),
  //fdt         (element.FEManager().TimeStep()),
  //ftime       (element.ElementSupport().Time()),
  //fStatus     (element.RunState()),
  fLocDisp    (support.LocalArray(LocalArrayT::kDisp)),
  fLocLastDisp(support.LocalArray(LocalArrayT::kLastDisp)),
  fKineticEqn (NULL),
  fSolver     (NULL),
  fSolverPtr  (new SolverWrapperEVPBase(*this)),
  fFtot       (kNSD),
  fs_ij       (kNSD),
  fc_ijkl     (dSymMatrixT::NumValues(kNSD))
{
ExceptionT::GeneralFail("EVPFDBaseT::EVPFDBaseT", "out of date");

  // input file
  StringT filename;
  in >> filename;
  
  // generate relative path in native format
  filename.ToNativePathName();
  StringT path;
  path.FilePath(in.filename());
  filename.Prepend(path);
  
  OpenExternal(fInput, filename, "EVPFDBaseT data");
  if (in.skip_comments())
    fInput.set_marker(in.comment_marker());

  // Lame's constants
  fmu     = Mu();
  flambda = Lambda();
  fbulk   = flambda + 2./3.*fmu;
}
/* accept parameter list */
void ThermomechanicalCouplingManagerT::TakeParameterList(const ParameterListT& list)
{
	const char caller[] = "ThermomechanicalCouplingManagerT::TakeParameterList";

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

	/* inherited - don't call direct base class method */
	ParameterInterfaceT::TakeParameterList(list);

	/* path to parameters file */
	StringT path;
	path.FilePath(fInputFile);
	TaskT task = kRun;

	/* parse/validate continuum input */
	StringT continuum_input = list.GetParameter("continuum_input");
	continuum_input.ToNativePathName();
	continuum_input.Prepend(path);
	ParameterListT continuum_params;
	ParseInput(continuum_input, continuum_params, true, true, true, fArgv);
			
	/* construct continuum solver */
	if (fCoarseComm->Size() != 1)
		ExceptionT::GeneralFail(caller, "parallel execution error");
	if (Size() > 1) /* change file name so output files are unique */  {
		StringT suffix;
		suffix.Suffix(continuum_input);
		continuum_input.Root();
		continuum_input.Append(".p", Rank());
		continuum_input.Append(suffix);
	}
	StringT continuum_output_file;
	continuum_output_file.Root(continuum_input);
	continuum_output_file.Append(".out");
	fCoarseOut.open(continuum_output_file);
	fCoarse = TB_DYNAMIC_CAST(FEManagerT_bridging*, FEManagerT::New(continuum_params.Name(), continuum_input, fCoarseOut, *fCoarseComm, fArgv, task));
	if (!fCoarse) ExceptionT::GeneralFail(caller, "could not construct continuum solver");
	fCoarse->TakeParameterList(continuum_params);

	/* parse/validate atomistic input */
	StringT atom_input = list.GetParameter("atom_input");
	atom_input.ToNativePathName();
	atom_input.Prepend(path);
	ParameterListT atom_params;
	ParseInput(atom_input, atom_params, true, true, true, fArgv);

	/* construct atomistic solver */
	if (Size() != fFineComm->Size())
		ExceptionT::GeneralFail(caller, "parallel execution error");
	StringT atom_output_file;
	atom_output_file.Root(atom_input);
	if (Size() > 1) atom_output_file.Append(".p", Rank());
	atom_output_file.Append(".out");
	fFineOut.open(atom_output_file);
	fFine = TB_DYNAMIC_CAST(FEManagerT_bridging*, FEManagerT::New(atom_params.Name(), atom_input, fFineOut, *fFineComm, fArgv, task));
	if (!fFine) ExceptionT::GeneralFail(caller, "could not construct atomistic solver");
	fFine->TakeParameterList(atom_params);

	/* check consistency between time managers */
	TimeManagerT* atom_time = fFine->TimeManager();
	TimeManagerT* continuum_time = fCoarse->TimeManager();

	/* use parameters from coarse scale solver */
	fTimeManager = fCoarse->TimeManager();
	fOutputFormat = fCoarse->OutputFormat();

	/* don't compute initial conditions */
	fFine->SetComputeInitialCondition(false);
	fCoarse->SetComputeInitialCondition(false);

	/* resolve bridging fields */
	const StringT& bridging_field = list.GetParameter("bridging_field");
	fFineField = fFine->NodeManager()->Field(bridging_field);
	if (!fFineField) ExceptionT::GeneralFail(caller, "could not resolve fine scale \"%s\" field", bridging_field.Pointer());
	fCoarseField = fCoarse->NodeManager()->Field(bridging_field);
	if (!fFineField) ExceptionT::GeneralFail(caller, "could not resolve coarse scale \"%s\" field", bridging_field.Pointer());

	/* resolve integrator types */
//	if (fFineField->Integrator().ImplicitExplicit() != fCoarseField->Integrator().ImplicitExplicit())
//		ExceptionT::GeneralFail(caller, "time integrator mismatch");
	fImpExp = fFineField->Integrator().ImplicitExplicit();

	/* collect the ghost atom ID list */
	ArrayT<StringT> ghost_atom_ID;
	const ParameterListT* ghosts = list.List("ghost_atom_ID_list");
	if (ghosts)	StringListT::Extract(*ghosts, ghost_atom_ID);

	/* configure projection/interpolation */
	NodeManagerT& fine_node_manager = *(fFine->NodeManager());	
	int group = 0;
	int order1 = 0;
	bool make_inactive = true;
	bool node_to_node = false;
	fFine->InitGhostNodes(fFineField->FieldName(), ghost_atom_ID, fCoarse->ProjectImagePoints());
	fCoarse->InitInterpolation(fFineField->FieldName(), fFine->GhostNodes(), fine_node_manager.InitialCoordinates());
	fCoarse->InitProjection(fFineField->FieldName(), *(fFine->CommManager()), fFine->NonGhostNodes(), fine_node_manager, make_inactive, node_to_node);

	/* send coarse/fine output through the fFine output */
	int ndof = fFine->NodeManager()->NumDOF(group);
	ArrayT<StringT> labels(2*ndof);
	const char* coarse_labels[] = {"UC_X", "UC_Y", "UC_Z"};
	const char* fine_labels[] = {"UF_X", "UF_Y", "UF_Z"};
	int dex = 0;
	for (int i = 0; i < ndof; i++) labels[dex++] = coarse_labels[i];
	for (int i = 0; i < ndof; i++) labels[dex++] = fine_labels[i];
	const iArrayT& non_ghost_nodes = fFine->NonGhostNodes();
	fAtomConnectivities.Alias(non_ghost_nodes.Length(), 1, non_ghost_nodes.Pointer());
	OutputSetT output_set(GeometryT::kPoint, fAtomConnectivities, labels, false);
	fOutputID = fFine->RegisterOutput(output_set);

	/* construct solver */
	int n1 = fFine->NumGroups();
	int n2 = fCoarse->NumGroups();
//	if (n1 != n2) ExceptionT::GeneralFail(caller, "number of groups must match: %d != %d", n1, n2);
	const ParameterListT* multi_solver = list.ListChoice(*this, "multi_solver_choice");
	if (multi_solver)
	{
		/* construct */
		SolverT* solver = SolverT::New(*this, multi_solver->Name(), 0);
		if (!solver) ExceptionT::GeneralFail(caller, "could not construct solver \"%s\"",
			multi_solver->Name().Pointer());
		solver->TakeParameterList(*multi_solver);
		
		/* store */
		fSolvers.Dimension(1);
		fSolvers[0] = solver;
	}
	SetSolver();

	/* default solver phases */
	fMaxSolverLoops = 1;
	fSolverPhases.Dimension(1, 3);
	fSolverPhases(0,0) = 0;
	fSolverPhases(0,1) =-1;
	fSolverPhases(0,2) =-1;
	fSolverPhasesStatus.Dimension(fSolverPhases.MajorDim(), kNumStatusFlags);
	fSolverPhasesStatus = 0;

	/* terms to include in the equilibrium equations */
	fFineToCoarse = list.GetParameter("fine_to_coarse");
	fCoarseToFine = list.GetParameter("coarse_to_fine");
	if (fCoarseToFine) /* enforce zero bond density in projected cells */
		fCoarse->DeactivateFollowerCells();

	/* needed to solve overlap */
	const dArray2DT& fine_init_coords = fine_node_manager.InitialCoordinates();
	const ParticlePairT* particle_pair = fFine->ParticlePair();
	if (!particle_pair) ExceptionT::GeneralFail(caller, "could not resolve ParticlePairT");
	
	/* overlap correction method */
	StringT overlap_path;
	const ParameterT* overlap_file = list.Parameter("overlap_file");
	if (overlap_file) {
		overlap_path = *overlap_file;
		overlap_path.ToNativePathName();

		StringT path;
		path.FilePath(fInputFile);
		overlap_path.Prepend(path);
	} /* default name */
	else {
		overlap_path.Root(fInputFile);
		overlap_path.Append(".overlap");
	}
	
	const ParameterListT& overlap = list.GetListChoice(*this, "overlap_correction_choice");
	if (overlap.Name() == "prescribe_overlap")
	{
		double density = overlap.GetParameter("bond_density");
		cout << "\n " << caller << ": \"prescribe_overlap\" not implemented. p = 1.0" << endl;
	}
	else if (overlap.Name() == "by-bond_multiplier")
	{
		/* extract parameters */
		double smoothing = overlap.GetParameter("smoothing");
		double bind_1 = overlap.GetParameter("bind_to_1.0");
		double reg = overlap.GetParameter("constraint_regularization");
		int nip = overlap.GetParameter("density_nip");
		double init_bound_width = overlap.GetParameter("init_bound_width");
		
		/* compute overlap correction */
		double bound_0 = init_bound_width/2.0;
		fCoarse->CorrectOverlap_2(particle_pair->Neighbors(), fine_init_coords, 
			overlap_path, smoothing, bind_1, reg, bound_0, nip);
	}
	else if (overlap.Name() == "by-bond_penalty")
	{
		/* extract parameters */
		double smoothing = overlap.GetParameter("smoothing");
		double bind_1 = overlap.GetParameter("bind_to_1.0");
		double bound_tol = overlap.GetParameter("bound_tolerance");
		double stiffness_jump = overlap.GetParameter("stiffness_jump");
		int nip = overlap.GetParameter("density_nip");
		
		/* compute overlap correction */
		fCoarse->CorrectOverlap_22(particle_pair->Neighbors(), fine_init_coords, 
			overlap_path, smoothing, bind_1, bound_tol, stiffness_jump, nip);
	}
	else
		ExceptionT::GeneralFail(caller, "unrecognized overlap correction method \"%s\"",
			overlap.Name().Pointer());



        /* output for kinetic temperature  */
	ModelManagerT* model = fCoarse->ModelManager();
        ArrayT<StringT> vlabels(1);
        const char* label[] = {"kT"};
        vlabels[0] = label[0];
	/* specify output - "free set" */
	const char* id = "1";
	StringT ID ; // HACK
	ID = fCoarse->ElementGroup(0)->ElementBlockID(1);
        OutputSetT coarse_output_set(model->ElementGroupGeometry(ID), model->ElementGroup(ID), vlabels);
        fCoarseOutputID = fCoarse->RegisterOutput(coarse_output_set);

	/* find particle class */
        for (int i = 0; i < fFine->NumElementGroups(); i++)
        {
           ElementBaseT* element_base = fFine->ElementGroup(i); 
           ParticleT* particle = dynamic_cast<ParticleT*>(element_base);
           if (particle) { fParticles = particle;   }
        }
}
/* accept parameter list */
void ABAQUS_UMAT_SS_BaseT::TakeParameterList(const ParameterListT& list)
{
	const char caller[] = "ABAQUS_UMAT_SS_BaseT::TakeParameterList";

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

	fDebug = list.GetParameter("debug");
	fUseUMATModulus = list.GetParameter("use_UMAT_modulus");
	fNumElasticIterations = list.GetParameter("elastic_iterations");

	/* dimension work space */
	int nsd = NumSD();
	fStress.Dimension(nsd);
	fIPCoordinates.Dimension(nsd);
	fmat_nsd.Dimension(nsd);
	fsym_mat_nsd.Dimension(dSymMatrixT::int2DimensionT(nsd));

	/* open UMAT parameters file */
	StringT path;
	path.FilePath(MaterialSupport().InputFile());
	StringT params = list.GetParameter("UMAT_parameter_file");
	params.ToNativePathName();
	params.Prepend(path);
	ifstreamT in('#', params);
	if (!in.is_open())
		ExceptionT::GeneralFail(caller, "could not open file \"%s\"",
			params.Pointer());

	/* read ABAQUS-format input */
	bool nonsym = false;	
	Read_ABAQUS_Input(in, fUMAT_name, fProperties, fDensity, nstatv, nonsym);
	if (nonsym)
		fTangentType = GlobalT::kNonSymmetric;

	/* notify */
	if (fThermal->IsActive())
		cout << "\n ABAQUS_UMAT_SS_BaseT::Initialize: thermal strains must\n"
		     <<   "    be handled within the UMAT\n" << endl;
	
	/* UMAT dimensions */
	ndi = 3; // always 3 direct components
	if (nsd == 2)
		nshr = 1;
	else if (nsd == 3)
		nshr = 3;
	else
		ExceptionT::GeneralFail(caller, "unexpected dimension %d", nsd);
	ntens = ndi + nshr;

	/* modulus storage */
	if (fTangentType == GlobalT::kDiagonal)
		fModulusDim = ntens;
	else if (fTangentType == GlobalT::kSymmetric)
	{
		if (nsd == 2) fModulusDim = 10;
		else if (nsd == 3) fModulusDim = 21;
		else ExceptionT::GeneralFail(caller);
	}
	else if (fTangentType == GlobalT::kNonSymmetric)
		fModulusDim = ntens*ntens;
	else
		ExceptionT::GeneralFail(caller);

	/* storage block size (per ip) */
	fBlockSize = 0;
	fBlockSize += ntens;       // fstress
	fBlockSize += ntens;       // fstrain
	fBlockSize += 3;           // fsse_pd_cd
	fBlockSize += nstatv;      // fstatv
	fBlockSize += fModulusDim; // fmodulus
	fBlockSize += ntens;       // fstress_last
	fBlockSize += ntens;       // fstrain_last
	fBlockSize += 3;           // fsse_pd_cd_last
	fBlockSize += nstatv;      // fstatv_last
	
	/* argument array */
	fArgsArray.Dimension(fBlockSize);

	/* assign pointers */
	doublereal* parg = fArgsArray.Pointer();
	fstress.Set(ntens, parg);        parg += ntens;
	fstrain.Set(ntens, parg);        parg += ntens;
	fsse_pd_cd.Set(3, parg);         parg += 3;
	fstatv.Set(nstatv, parg);        parg += nstatv;
	fmodulus.Set(fModulusDim, parg); parg += fModulusDim;
	fstress_last.Set(ntens, parg);   parg += ntens;
	fstrain_last.Set(ntens, parg);   parg += ntens;
	fsse_pd_cd_last.Set(3, parg);    parg += 3;
	fstatv_last.Set(nstatv, parg);

	/* UMAT array arguments */
	fddsdde.Dimension(ntens);
	fddsdde = 0.0;
	fdstran.Dimension(ntens);
	fdstran = 0.0;
	fdrot.Dimension(3);   // always 3
	fdrot.Identity();
	fdfgrd0.Dimension(3); // always 3
	fdfgrd0.Identity();
	fdfgrd1.Dimension(3); // always 3
	fdfgrd1.Identity();
	fcoords.Dimension(nsd);

	/* write properties */
	ofstreamT& out = MaterialSupport().Output();	
	out << " Number of ABAQUS UMAT internal variables. . . . = " << nstatv << '\n';
	out << " Number of ABAQUS UMAT properties. . . . . . . . = " << fProperties.Length() << '\n';
	PrintProperties(out);

	/* set material output variables/labels */
	SetOutputVariables(fOutputIndex, fOutputLabels);
}